home *** CD-ROM | disk | FTP | other *** search
/ Complete Linux / Complete Linux.iso / docs / devel / eiffel / eiffel_p.z / eiffel_p / ep / Tree.c < prev    next >
Encoding:
C/C++ Source or Header  |  1992-12-09  |  363.3 KB  |  12,903 lines
  1. # include "Tree.h"
  2. # define yyALLOC(ptr, size)    if ((ptr = (tTree) Tree_PoolFreePtr) >= (tTree) Tree_PoolMaxPtr) \
  3.   ptr = Tree_Alloc (); \
  4.   Tree_PoolFreePtr += size;
  5. # define yyFREE(ptr, size)    
  6. # ifdef __cplusplus
  7. extern "C" {
  8. # include <stdio.h>
  9. # include "yyTree.w"
  10. # include "System.h"
  11. # include "General.h"
  12. # include "Memory.h"
  13. # include "DynArray.h"
  14. # include "StringMem.h"
  15. # include "Idents.h"
  16. # include "Sets.h"
  17. # include "Positions.h"
  18. }
  19. # else
  20. # include <stdio.h>
  21. # include "yyTree.w"
  22. # include "System.h"
  23. # include "General.h"
  24. # include "Memory.h"
  25. # include "DynArray.h"
  26. # include "StringMem.h"
  27. # include "Idents.h"
  28. # include "Sets.h"
  29. # include "Positions.h"
  30. # endif
  31.  
  32. /* line 10 "eiffel.ast" */
  33.  
  34. char str[COMMENT_SIZE];
  35.  
  36. #define writetPosition(a)    (void) fprintf(yyf,"%4d %3d", a.Line, a.Column);
  37. #define readtPosition(a)    (void) fscanf(yyf, "%hd%hd", &a.Line, &a.Column);
  38. #define gettPosition(a)        (void) fscanf(yyf, "%hd%hd%*c", &a.Line, &a.Column);
  39. #define puttPosition(a)        (void) fprintf(yyf,"%4d %3d\n", a.Line, a.Column);
  40. #define readdouble(a)        (void) fscanf(yyf, "%lG", &a);
  41. #define writedouble(a)        (void) fprintf(yyf, "%lG", a);
  42. #define writetStringRef(a)    StGetString(a, str);\
  43.                 (void) fprintf(yyf, "%s", str);putc('\0',yyf);
  44. #define readtStringRef(a)    getStr(yyf); a = PutString(str,strlen(str));    
  45. #define gettStringRef(a)    getStr(yyf); a = PutString(str,strlen(str));
  46. #define puttStringRef(a)    StGetString(a, str);\
  47.                 (void) fprintf(yyf, "%s", str);putc('\0',yyf);
  48.  
  49. #ifdef Select    /* because in Sets.h Select is already defined    */    
  50. #undef Select
  51. #endif
  52.  
  53. void getStr(fp)
  54. FILE *fp;
  55. {
  56.     unsigned i = 0;
  57.  
  58.     while((str[i] = getc(fp)) != 0) i++;
  59.     
  60. }
  61.     
  62.  
  63.  
  64. static void yyExit () { Exit (1); }
  65.  
  66. void (* Tree_Exit) () = yyExit;
  67.  
  68. # define yyBlockSize 20480
  69.  
  70. typedef struct yysBlock {
  71.  char yyBlock [yyBlockSize];
  72.  struct yysBlock * yySuccessor;
  73. } yytBlock, * yytBlockPtr;
  74.  
  75. tTree TreeRoot;
  76. unsigned long Tree_HeapUsed = 0;
  77.  
  78. static yytBlockPtr yyBlockList    = (yytBlockPtr) NoTree;
  79. char * Tree_PoolFreePtr    = (char *) NoTree;
  80. char * Tree_PoolMaxPtr    = (char *) NoTree;
  81. static unsigned short yyMaxSize    = 0;
  82. unsigned short Tree_NodeSize [192 + 1] = { 0,
  83.  sizeof (yEiffel),
  84.  sizeof (yClasses),
  85.  sizeof (yClasses0),
  86.  sizeof (yClasses1),
  87.  sizeof (yClass_declaration),
  88.  sizeof (yIndex_list),
  89.  sizeof (yIndex_list0),
  90.  sizeof (yIndex_list1),
  91.  sizeof (yIndex_clause),
  92.  sizeof (yClass_header),
  93.  sizeof (yClass_header0),
  94.  sizeof (yClass),
  95.  sizeof (yExpanded_class),
  96.  sizeof (yDeferred_class),
  97.  sizeof (yFeatures),
  98.  sizeof (yFeatures0),
  99.  sizeof (yFeatures1),
  100.  sizeof (yFeature_clause),
  101.  sizeof (yClients),
  102.  sizeof (yClients0),
  103.  sizeof (yClients1),
  104.  sizeof (yFeature_decls),
  105.  sizeof (yFeature_decls0),
  106.  sizeof (yFeature_decls1),
  107.  sizeof (yFeature_decl),
  108.  sizeof (yDeclaration_body),
  109.  sizeof (yConst_or_routine),
  110.  sizeof (yConst_or_routine0),
  111.  sizeof (yM_const),
  112.  sizeof (yUnique),
  113.  sizeof (yRoutine),
  114.  sizeof (yParent_list),
  115.  sizeof (yParent_list0),
  116.  sizeof (yParent_list1),
  117.  sizeof (yParent),
  118.  sizeof (yFeature_adaptation),
  119.  sizeof (yFeature_adaptation0),
  120.  sizeof (yFeature_adaptation1),
  121.  sizeof (yRename_list),
  122.  sizeof (yRename_list0),
  123.  sizeof (yRename_list1),
  124.  sizeof (yRename_pair),
  125.  sizeof (yCreators),
  126.  sizeof (yCreators0),
  127.  sizeof (yCreators1),
  128.  sizeof (yCreation_clause),
  129.  sizeof (yNew_feature_list),
  130.  sizeof (yNew_feature_list0),
  131.  sizeof (yNew_feature_list1),
  132.  sizeof (yFeature_name),
  133.  sizeof (yFrozen),
  134.  sizeof (yIdent_name),
  135.  sizeof (yOp),
  136.  sizeof (yPrefix),
  137.  sizeof (yInfix),
  138.  sizeof (yOp_name),
  139.  sizeof (yFree_op),
  140.  sizeof (yOper),
  141.  sizeof (yNew_export_list),
  142.  sizeof (yNew_export_list0),
  143.  sizeof (yNew_export_list1),
  144.  sizeof (yNew_export_item),
  145.  sizeof (yFeature_list),
  146.  sizeof (yAll),
  147.  sizeof (yFeature_list0),
  148.  sizeof (yFeature_list1),
  149.  sizeof (yFormal_args),
  150.  sizeof (yFormal_args0),
  151.  sizeof (yFormal_args1),
  152.  sizeof (yRoutine_body),
  153.  sizeof (yRoutine_body0),
  154.  sizeof (yEffective),
  155.  sizeof (yInternal),
  156.  sizeof (yDo_body),
  157.  sizeof (yOnce_body),
  158.  sizeof (yExternal),
  159.  sizeof (yDeferred),
  160.  sizeof (yEntity_decl_group),
  161.  sizeof (yFormal_generics),
  162.  sizeof (yFormal_generics0),
  163.  sizeof (yFormal_generics1),
  164.  sizeof (yFormal_generic),
  165.  sizeof (yConstraint),
  166.  sizeof (yConstraint0),
  167.  sizeof (yConstraint1),
  168.  sizeof (yCompound),
  169.  sizeof (yCompound0),
  170.  sizeof (yCompound1),
  171.  sizeof (yThen_part_list),
  172.  sizeof (yThen_part_list0),
  173.  sizeof (yThen_part_list1),
  174.  sizeof (yThen_part),
  175.  sizeof (yWhen_part_list),
  176.  sizeof (yWhen_part_list0),
  177.  sizeof (yWhen_part_list1),
  178.  sizeof (yWhen_part),
  179.  sizeof (yChoices),
  180.  sizeof (yChoices0),
  181.  sizeof (yChoices1),
  182.  sizeof (yChoice),
  183.  sizeof (yInterval),
  184.  sizeof (yVal),
  185.  sizeof (yInstruction),
  186.  sizeof (yInstruction0),
  187.  sizeof (yCreation),
  188.  sizeof (yCall_instruct),
  189.  sizeof (yAssign),
  190.  sizeof (yRev_assign),
  191.  sizeof (yConditional),
  192.  sizeof (yMulti_branch),
  193.  sizeof (yLoop),
  194.  sizeof (yCheck),
  195.  sizeof (yDebug),
  196.  sizeof (yRetry),
  197.  sizeof (yLoop_body),
  198.  sizeof (yLoop_body0),
  199.  sizeof (yLoop_body1),
  200.  sizeof (yType),
  201.  sizeof (yType0),
  202.  sizeof (yClass_type),
  203.  sizeof (yClass_type_expanded),
  204.  sizeof (yBit_type),
  205.  sizeof (ySimple_type),
  206.  sizeof (yAnchored),
  207.  sizeof (yActual_generics),
  208.  sizeof (yActual_generics0),
  209.  sizeof (yActual_generics1),
  210.  sizeof (yCondition),
  211.  sizeof (yCondition0),
  212.  sizeof (yCondition1),
  213.  sizeof (yAssertion),
  214.  sizeof (yAssertion0),
  215.  sizeof (yAssertion1),
  216.  sizeof (yAssertion_clause),
  217.  sizeof (yAssertion_clause0),
  218.  sizeof (yAssertion_clause1),
  219.  sizeof (yType_list),
  220.  sizeof (yType_list0),
  221.  sizeof (yType_list1),
  222.  sizeof (yCall_chain),
  223.  sizeof (yCall_chain0),
  224.  sizeof (yCall_chain1),
  225.  sizeof (yUnqual_call),
  226.  sizeof (yUnqual_call0),
  227.  sizeof (yUnqual_call1),
  228.  sizeof (yActuals),
  229.  sizeof (yActuals0),
  230.  sizeof (yActuals1),
  231.  sizeof (yActual_list),
  232.  sizeof (yActual_list0),
  233.  sizeof (yActual_list1),
  234.  sizeof (yActual),
  235.  sizeof (yAddr),
  236.  sizeof (yExpression),
  237.  sizeof (yExpression0),
  238.  sizeof (yComment),
  239.  sizeof (ySimple_expr),
  240.  sizeof (yCall),
  241.  sizeof (yBin_expr),
  242.  sizeof (yUn_expr),
  243.  sizeof (yParenth),
  244.  sizeof (yManifest_array),
  245.  sizeof (yManifest_array0),
  246.  sizeof (yManifest_array1),
  247.  sizeof (yOld),
  248.  sizeof (yStrip),
  249.  sizeof (yList),
  250.  sizeof (ynolist),
  251.  sizeof (ylist),
  252.  sizeof (yManifest_constant),
  253.  sizeof (yManifest_constant0),
  254.  sizeof (yCh),
  255.  sizeof (yTrue),
  256.  sizeof (yFalse),
  257.  sizeof (yInt),
  258.  sizeof (yReal),
  259.  sizeof (y_CHARACTER),
  260.  sizeof (y_INTEGER),
  261.  sizeof (y_REAL),
  262.  sizeof (y_DOUBLE),
  263.  sizeof (y_BOOLEAN),
  264.  sizeof (y_STRING),
  265.  sizeof (y_BIT),
  266.  sizeof (y_NONE),
  267.  sizeof (yBitseq),
  268.  sizeof (yString),
  269.  sizeof (yString0),
  270.  sizeof (yEntity),
  271.  sizeof (yEntity0),
  272.  sizeof (yCurrent),
  273.  sizeof (yResult),
  274.  sizeof (yId),
  275. };
  276. char * Tree_NodeName [192 + 1] = {
  277.  "NoTree",
  278.  "Eiffel",
  279.  "Classes",
  280.  "Classes0",
  281.  "Classes1",
  282.  "Class_declaration",
  283.  "Index_list",
  284.  "Index_list0",
  285.  "Index_list1",
  286.  "Index_clause",
  287.  "Class_header",
  288.  "Class_header0",
  289.  "Class",
  290.  "Expanded_class",
  291.  "Deferred_class",
  292.  "Features",
  293.  "Features0",
  294.  "Features1",
  295.  "Feature_clause",
  296.  "Clients",
  297.  "Clients0",
  298.  "Clients1",
  299.  "Feature_decls",
  300.  "Feature_decls0",
  301.  "Feature_decls1",
  302.  "Feature_decl",
  303.  "Declaration_body",
  304.  "Const_or_routine",
  305.  "Const_or_routine0",
  306.  "M_const",
  307.  "Unique",
  308.  "Routine",
  309.  "Parent_list",
  310.  "Parent_list0",
  311.  "Parent_list1",
  312.  "Parent",
  313.  "Feature_adaptation",
  314.  "Feature_adaptation0",
  315.  "Feature_adaptation1",
  316.  "Rename_list",
  317.  "Rename_list0",
  318.  "Rename_list1",
  319.  "Rename_pair",
  320.  "Creators",
  321.  "Creators0",
  322.  "Creators1",
  323.  "Creation_clause",
  324.  "New_feature_list",
  325.  "New_feature_list0",
  326.  "New_feature_list1",
  327.  "Feature_name",
  328.  "Frozen",
  329.  "Ident_name",
  330.  "Op",
  331.  "Prefix",
  332.  "Infix",
  333.  "Op_name",
  334.  "Free_op",
  335.  "Oper",
  336.  "New_export_list",
  337.  "New_export_list0",
  338.  "New_export_list1",
  339.  "New_export_item",
  340.  "Feature_list",
  341.  "All",
  342.  "Feature_list0",
  343.  "Feature_list1",
  344.  "Formal_args",
  345.  "Formal_args0",
  346.  "Formal_args1",
  347.  "Routine_body",
  348.  "Routine_body0",
  349.  "Effective",
  350.  "Internal",
  351.  "Do_body",
  352.  "Once_body",
  353.  "External",
  354.  "Deferred",
  355.  "Entity_decl_group",
  356.  "Formal_generics",
  357.  "Formal_generics0",
  358.  "Formal_generics1",
  359.  "Formal_generic",
  360.  "Constraint",
  361.  "Constraint0",
  362.  "Constraint1",
  363.  "Compound",
  364.  "Compound0",
  365.  "Compound1",
  366.  "Then_part_list",
  367.  "Then_part_list0",
  368.  "Then_part_list1",
  369.  "Then_part",
  370.  "When_part_list",
  371.  "When_part_list0",
  372.  "When_part_list1",
  373.  "When_part",
  374.  "Choices",
  375.  "Choices0",
  376.  "Choices1",
  377.  "Choice",
  378.  "Interval",
  379.  "Val",
  380.  "Instruction",
  381.  "Instruction0",
  382.  "Creation",
  383.  "Call_instruct",
  384.  "Assign",
  385.  "Rev_assign",
  386.  "Conditional",
  387.  "Multi_branch",
  388.  "Loop",
  389.  "Check",
  390.  "Debug",
  391.  "Retry",
  392.  "Loop_body",
  393.  "Loop_body0",
  394.  "Loop_body1",
  395.  "Type",
  396.  "Type0",
  397.  "Class_type",
  398.  "Class_type_expanded",
  399.  "Bit_type",
  400.  "Simple_type",
  401.  "Anchored",
  402.  "Actual_generics",
  403.  "Actual_generics0",
  404.  "Actual_generics1",
  405.  "Condition",
  406.  "Condition0",
  407.  "Condition1",
  408.  "Assertion",
  409.  "Assertion0",
  410.  "Assertion1",
  411.  "Assertion_clause",
  412.  "Assertion_clause0",
  413.  "Assertion_clause1",
  414.  "Type_list",
  415.  "Type_list0",
  416.  "Type_list1",
  417.  "Call_chain",
  418.  "Call_chain0",
  419.  "Call_chain1",
  420.  "Unqual_call",
  421.  "Unqual_call0",
  422.  "Unqual_call1",
  423.  "Actuals",
  424.  "Actuals0",
  425.  "Actuals1",
  426.  "Actual_list",
  427.  "Actual_list0",
  428.  "Actual_list1",
  429.  "Actual",
  430.  "Addr",
  431.  "Expression",
  432.  "Expression0",
  433.  "Comment",
  434.  "Simple_expr",
  435.  "Call",
  436.  "Bin_expr",
  437.  "Un_expr",
  438.  "Parenth",
  439.  "Manifest_array",
  440.  "Manifest_array0",
  441.  "Manifest_array1",
  442.  "Old",
  443.  "Strip",
  444.  "List",
  445.  "nolist",
  446.  "list",
  447.  "Manifest_constant",
  448.  "Manifest_constant0",
  449.  "Ch",
  450.  "True",
  451.  "False",
  452.  "Int",
  453.  "Real",
  454.  "_CHARACTER",
  455.  "_INTEGER",
  456.  "_REAL",
  457.  "_DOUBLE",
  458.  "_BOOLEAN",
  459.  "_STRING",
  460.  "_BIT",
  461.  "_NONE",
  462.  "Bitseq",
  463.  "String",
  464.  "String0",
  465.  "Entity",
  466.  "Entity0",
  467.  "Current",
  468.  "Result",
  469.  "Id",
  470. };
  471. static Tree_tKind yyTypeRange [192 + 1] = { 0,
  472.  kEiffel,
  473.  kClasses1,
  474.  kClasses0,
  475.  kClasses1,
  476.  kClass_declaration,
  477.  kIndex_list1,
  478.  kIndex_list0,
  479.  kIndex_list1,
  480.  kIndex_clause,
  481.  kDeferred_class,
  482.  kClass_header0,
  483.  kClass,
  484.  kExpanded_class,
  485.  kDeferred_class,
  486.  kFeatures1,
  487.  kFeatures0,
  488.  kFeatures1,
  489.  kFeature_clause,
  490.  kClients1,
  491.  kClients0,
  492.  kClients1,
  493.  kFeature_decls1,
  494.  kFeature_decls0,
  495.  kFeature_decls1,
  496.  kFeature_decl,
  497.  kDeclaration_body,
  498.  kRoutine,
  499.  kConst_or_routine0,
  500.  kM_const,
  501.  kUnique,
  502.  kRoutine,
  503.  kParent_list1,
  504.  kParent_list0,
  505.  kParent_list1,
  506.  kParent,
  507.  kFeature_adaptation1,
  508.  kFeature_adaptation0,
  509.  kFeature_adaptation1,
  510.  kRename_list1,
  511.  kRename_list0,
  512.  kRename_list1,
  513.  kRename_pair,
  514.  kCreators1,
  515.  kCreators0,
  516.  kCreators1,
  517.  kCreation_clause,
  518.  kNew_feature_list1,
  519.  kNew_feature_list0,
  520.  kNew_feature_list1,
  521.  kInfix,
  522.  kFrozen,
  523.  kIdent_name,
  524.  kInfix,
  525.  kPrefix,
  526.  kInfix,
  527.  kOper,
  528.  kFree_op,
  529.  kOper,
  530.  kNew_export_list1,
  531.  kNew_export_list0,
  532.  kNew_export_list1,
  533.  kNew_export_item,
  534.  kFeature_list1,
  535.  kAll,
  536.  kFeature_list0,
  537.  kFeature_list1,
  538.  kFormal_args1,
  539.  kFormal_args0,
  540.  kFormal_args1,
  541.  kDeferred,
  542.  kRoutine_body0,
  543.  kExternal,
  544.  kOnce_body,
  545.  kDo_body,
  546.  kOnce_body,
  547.  kExternal,
  548.  kDeferred,
  549.  kEntity_decl_group,
  550.  kFormal_generics1,
  551.  kFormal_generics0,
  552.  kFormal_generics1,
  553.  kFormal_generic,
  554.  kConstraint1,
  555.  kConstraint0,
  556.  kConstraint1,
  557.  kCompound1,
  558.  kCompound0,
  559.  kCompound1,
  560.  kThen_part_list1,
  561.  kThen_part_list0,
  562.  kThen_part_list1,
  563.  kThen_part,
  564.  kWhen_part_list1,
  565.  kWhen_part_list0,
  566.  kWhen_part_list1,
  567.  kWhen_part,
  568.  kChoices1,
  569.  kChoices0,
  570.  kChoices1,
  571.  kVal,
  572.  kInterval,
  573.  kVal,
  574.  kRetry,
  575.  kInstruction0,
  576.  kCreation,
  577.  kCall_instruct,
  578.  kAssign,
  579.  kRev_assign,
  580.  kConditional,
  581.  kMulti_branch,
  582.  kLoop,
  583.  kCheck,
  584.  kDebug,
  585.  kRetry,
  586.  kLoop_body1,
  587.  kLoop_body0,
  588.  kLoop_body1,
  589.  kAnchored,
  590.  kType0,
  591.  kClass_type,
  592.  kClass_type_expanded,
  593.  kBit_type,
  594.  kSimple_type,
  595.  kAnchored,
  596.  kActual_generics1,
  597.  kActual_generics0,
  598.  kActual_generics1,
  599.  kCondition1,
  600.  kCondition0,
  601.  kCondition1,
  602.  kAssertion1,
  603.  kAssertion0,
  604.  kAssertion1,
  605.  kAssertion_clause1,
  606.  kAssertion_clause0,
  607.  kAssertion_clause1,
  608.  kType_list1,
  609.  kType_list0,
  610.  kType_list1,
  611.  kCall_chain1,
  612.  kCall_chain0,
  613.  kCall_chain1,
  614.  kUnqual_call1,
  615.  kUnqual_call0,
  616.  kUnqual_call1,
  617.  kActuals1,
  618.  kActuals0,
  619.  kActuals1,
  620.  kActual_list1,
  621.  kActual_list0,
  622.  kActual_list1,
  623.  kStrip,
  624.  kAddr,
  625.  kStrip,
  626.  kExpression0,
  627.  kComment,
  628.  kSimple_expr,
  629.  kCall,
  630.  kBin_expr,
  631.  kUn_expr,
  632.  kParenth,
  633.  kManifest_array1,
  634.  kManifest_array0,
  635.  kManifest_array1,
  636.  kOld,
  637.  kStrip,
  638.  klist,
  639.  knolist,
  640.  klist,
  641.  kId,
  642.  kManifest_constant0,
  643.  kCh,
  644.  kTrue,
  645.  kFalse,
  646.  kInt,
  647.  kReal,
  648.  k_CHARACTER,
  649.  k_INTEGER,
  650.  k_REAL,
  651.  k_DOUBLE,
  652.  k_BOOLEAN,
  653.  k_STRING,
  654.  k_BIT,
  655.  k_NONE,
  656.  kBitseq,
  657.  kString,
  658.  kString0,
  659.  kId,
  660.  kEntity0,
  661.  kCurrent,
  662.  kResult,
  663.  kId,
  664. };
  665.  
  666. tTree Tree_Alloc ()
  667. {
  668.  register yytBlockPtr yyBlockPtr = yyBlockList;
  669.  register int i;
  670.  
  671.  if (yyMaxSize == 0)
  672.   for (i = 1; i <= 192; i ++) {
  673.    Tree_NodeSize [i] = (Tree_NodeSize [i] + yyMaxAlign - 1) & yyAlignMasks [yyMaxAlign];
  674.    yyMaxSize = Max (Tree_NodeSize [i], yyMaxSize);
  675.   }
  676.  yyBlockList = (yytBlockPtr) Alloc (sizeof (yytBlock));
  677.  yyBlockList->yySuccessor = yyBlockPtr;
  678.  Tree_PoolFreePtr = yyBlockList->yyBlock;
  679.  Tree_PoolMaxPtr = Tree_PoolFreePtr + yyBlockSize - yyMaxSize + 1;
  680.  Tree_HeapUsed += yyBlockSize;
  681.  return (tTree) Tree_PoolFreePtr;
  682. }
  683.  
  684. tTree MakeTree
  685. # if defined __STDC__ | defined __cplusplus
  686.  (Tree_tKind yyKind)
  687. # else
  688.  (yyKind) Tree_tKind yyKind;
  689. # endif
  690. {
  691.  register tTree yyt;
  692.  yyALLOC (yyt, Tree_NodeSize [yyKind])
  693.  yyt->Kind = yyKind;
  694.  yyt->yyHead.yyMark = 0;
  695.  return yyt;
  696. }
  697.  
  698. bool Tree_IsType
  699. # if defined __STDC__ | defined __cplusplus
  700.  (register tTree yyt, register Tree_tKind yyKind)
  701. # else
  702.  (yyt, yyKind) register tTree yyt; register Tree_tKind yyKind;
  703. # endif
  704. {
  705.  return yyt != NoTree && yyKind <= yyt->Kind && yyt->Kind <= yyTypeRange [yyKind];
  706. }
  707.  
  708. tTree nEiffel () {
  709.  register tTree yyt;
  710.  yyALLOC (yyt, Tree_NodeSize [kEiffel])
  711.  yyt->Kind = kEiffel;
  712.  yyt->yyHead.yyMark = 0;
  713.  begintTree(yyt->Eiffel.Classes)
  714.  return yyt;
  715. }
  716.  
  717. tTree nClasses () {
  718.  register tTree yyt;
  719.  yyALLOC (yyt, Tree_NodeSize [kClasses])
  720.  yyt->Kind = kClasses;
  721.  yyt->yyHead.yyMark = 0;
  722.  return yyt;
  723. }
  724.  
  725. tTree nClasses0 () {
  726.  register tTree yyt;
  727.  yyALLOC (yyt, Tree_NodeSize [kClasses0])
  728.  yyt->Kind = kClasses0;
  729.  yyt->yyHead.yyMark = 0;
  730.  return yyt;
  731. }
  732.  
  733. tTree nClasses1 () {
  734.  register tTree yyt;
  735.  yyALLOC (yyt, Tree_NodeSize [kClasses1])
  736.  yyt->Kind = kClasses1;
  737.  yyt->yyHead.yyMark = 0;
  738.  begintTree(yyt->Classes1.Class_declaration)
  739.  begintTree(yyt->Classes1.Classes)
  740.  return yyt;
  741. }
  742.  
  743. tTree nClass_declaration () {
  744.  register tTree yyt;
  745.  yyALLOC (yyt, Tree_NodeSize [kClass_declaration])
  746.  yyt->Kind = kClass_declaration;
  747.  yyt->yyHead.yyMark = 0;
  748.  begintTree(yyt->Class_declaration.Indexing)
  749.  begintTree(yyt->Class_declaration.Class_header)
  750.  begintTree(yyt->Class_declaration.Formal_generics)
  751.  begintTree(yyt->Class_declaration.Obsolete)
  752.  begintTree(yyt->Class_declaration.Inheritance)
  753.  begintTree(yyt->Class_declaration.Creators)
  754.  begintTree(yyt->Class_declaration.Features)
  755.  begintTree(yyt->Class_declaration.Invariant)
  756.  begintStringRef(yyt->Class_declaration.comment)
  757.  return yyt;
  758. }
  759.  
  760. tTree nIndex_list () {
  761.  register tTree yyt;
  762.  yyALLOC (yyt, Tree_NodeSize [kIndex_list])
  763.  yyt->Kind = kIndex_list;
  764.  yyt->yyHead.yyMark = 0;
  765.  return yyt;
  766. }
  767.  
  768. tTree nIndex_list0 () {
  769.  register tTree yyt;
  770.  yyALLOC (yyt, Tree_NodeSize [kIndex_list0])
  771.  yyt->Kind = kIndex_list0;
  772.  yyt->yyHead.yyMark = 0;
  773.  return yyt;
  774. }
  775.  
  776. tTree nIndex_list1 () {
  777.  register tTree yyt;
  778.  yyALLOC (yyt, Tree_NodeSize [kIndex_list1])
  779.  yyt->Kind = kIndex_list1;
  780.  yyt->yyHead.yyMark = 0;
  781.  begintTree(yyt->Index_list1.Index_clause)
  782.  begintTree(yyt->Index_list1.Index_list)
  783.  return yyt;
  784. }
  785.  
  786. tTree nIndex_clause () {
  787.  register tTree yyt;
  788.  yyALLOC (yyt, Tree_NodeSize [kIndex_clause])
  789.  yyt->Kind = kIndex_clause;
  790.  yyt->yyHead.yyMark = 0;
  791.  begintTree(yyt->Index_clause.Index)
  792.  begintTree(yyt->Index_clause.Index_terms)
  793.  return yyt;
  794. }
  795.  
  796. tTree nClass_header () {
  797.  register tTree yyt;
  798.  yyALLOC (yyt, Tree_NodeSize [kClass_header])
  799.  yyt->Kind = kClass_header;
  800.  yyt->yyHead.yyMark = 0;
  801.  return yyt;
  802. }
  803.  
  804. tTree nClass_header0 () {
  805.  register tTree yyt;
  806.  yyALLOC (yyt, Tree_NodeSize [kClass_header0])
  807.  yyt->Kind = kClass_header0;
  808.  yyt->yyHead.yyMark = 0;
  809.  return yyt;
  810. }
  811.  
  812. tTree nClass () {
  813.  register tTree yyt;
  814.  yyALLOC (yyt, Tree_NodeSize [kClass])
  815.  yyt->Kind = kClass;
  816.  yyt->yyHead.yyMark = 0;
  817.  begintTree(yyt->Class.Name)
  818.  return yyt;
  819. }
  820.  
  821. tTree nExpanded_class () {
  822.  register tTree yyt;
  823.  yyALLOC (yyt, Tree_NodeSize [kExpanded_class])
  824.  yyt->Kind = kExpanded_class;
  825.  yyt->yyHead.yyMark = 0;
  826.  begintTree(yyt->Expanded_class.Name)
  827.  return yyt;
  828. }
  829.  
  830. tTree nDeferred_class () {
  831.  register tTree yyt;
  832.  yyALLOC (yyt, Tree_NodeSize [kDeferred_class])
  833.  yyt->Kind = kDeferred_class;
  834.  yyt->yyHead.yyMark = 0;
  835.  begintTree(yyt->Deferred_class.Name)
  836.  return yyt;
  837. }
  838.  
  839. tTree nFeatures () {
  840.  register tTree yyt;
  841.  yyALLOC (yyt, Tree_NodeSize [kFeatures])
  842.  yyt->Kind = kFeatures;
  843.  yyt->yyHead.yyMark = 0;
  844.  return yyt;
  845. }
  846.  
  847. tTree nFeatures0 () {
  848.  register tTree yyt;
  849.  yyALLOC (yyt, Tree_NodeSize [kFeatures0])
  850.  yyt->Kind = kFeatures0;
  851.  yyt->yyHead.yyMark = 0;
  852.  return yyt;
  853. }
  854.  
  855. tTree nFeatures1 () {
  856.  register tTree yyt;
  857.  yyALLOC (yyt, Tree_NodeSize [kFeatures1])
  858.  yyt->Kind = kFeatures1;
  859.  yyt->yyHead.yyMark = 0;
  860.  begintTree(yyt->Features1.Feature_clause)
  861.  begintTree(yyt->Features1.Features)
  862.  return yyt;
  863. }
  864.  
  865. tTree nFeature_clause () {
  866.  register tTree yyt;
  867.  yyALLOC (yyt, Tree_NodeSize [kFeature_clause])
  868.  yyt->Kind = kFeature_clause;
  869.  yyt->yyHead.yyMark = 0;
  870.  begintTree(yyt->Feature_clause.Clients)
  871.  begintStringRef(yyt->Feature_clause.comment)
  872.  begintTree(yyt->Feature_clause.Feature_decls)
  873.  return yyt;
  874. }
  875.  
  876. tTree nClients () {
  877.  register tTree yyt;
  878.  yyALLOC (yyt, Tree_NodeSize [kClients])
  879.  yyt->Kind = kClients;
  880.  yyt->yyHead.yyMark = 0;
  881.  return yyt;
  882. }
  883.  
  884. tTree nClients0 () {
  885.  register tTree yyt;
  886.  yyALLOC (yyt, Tree_NodeSize [kClients0])
  887.  yyt->Kind = kClients0;
  888.  yyt->yyHead.yyMark = 0;
  889.  return yyt;
  890. }
  891.  
  892. tTree nClients1 () {
  893.  register tTree yyt;
  894.  yyALLOC (yyt, Tree_NodeSize [kClients1])
  895.  yyt->Kind = kClients1;
  896.  yyt->yyHead.yyMark = 0;
  897.  begintTree(yyt->Clients1.List)
  898.  return yyt;
  899. }
  900.  
  901. tTree nFeature_decls () {
  902.  register tTree yyt;
  903.  yyALLOC (yyt, Tree_NodeSize [kFeature_decls])
  904.  yyt->Kind = kFeature_decls;
  905.  yyt->yyHead.yyMark = 0;
  906.  return yyt;
  907. }
  908.  
  909. tTree nFeature_decls0 () {
  910.  register tTree yyt;
  911.  yyALLOC (yyt, Tree_NodeSize [kFeature_decls0])
  912.  yyt->Kind = kFeature_decls0;
  913.  yyt->yyHead.yyMark = 0;
  914.  return yyt;
  915. }
  916.  
  917. tTree nFeature_decls1 () {
  918.  register tTree yyt;
  919.  yyALLOC (yyt, Tree_NodeSize [kFeature_decls1])
  920.  yyt->Kind = kFeature_decls1;
  921.  yyt->yyHead.yyMark = 0;
  922.  begintTree(yyt->Feature_decls1.Feature_decl)
  923.  begintTree(yyt->Feature_decls1.Feature_decls)
  924.  return yyt;
  925. }
  926.  
  927. tTree nFeature_decl () {
  928.  register tTree yyt;
  929.  yyALLOC (yyt, Tree_NodeSize [kFeature_decl])
  930.  yyt->Kind = kFeature_decl;
  931.  yyt->yyHead.yyMark = 0;
  932.  begintTree(yyt->Feature_decl.New_feature_list)
  933.  begintTree(yyt->Feature_decl.Declaration_body)
  934.  return yyt;
  935. }
  936.  
  937. tTree nDeclaration_body () {
  938.  register tTree yyt;
  939.  yyALLOC (yyt, Tree_NodeSize [kDeclaration_body])
  940.  yyt->Kind = kDeclaration_body;
  941.  yyt->yyHead.yyMark = 0;
  942.  begintTree(yyt->Declaration_body.Formal_args)
  943.  begintTree(yyt->Declaration_body.Type_mark)
  944.  begintTree(yyt->Declaration_body.Const_or_routine)
  945.  return yyt;
  946. }
  947.  
  948. tTree nConst_or_routine () {
  949.  register tTree yyt;
  950.  yyALLOC (yyt, Tree_NodeSize [kConst_or_routine])
  951.  yyt->Kind = kConst_or_routine;
  952.  yyt->yyHead.yyMark = 0;
  953.  return yyt;
  954. }
  955.  
  956. tTree nConst_or_routine0 () {
  957.  register tTree yyt;
  958.  yyALLOC (yyt, Tree_NodeSize [kConst_or_routine0])
  959.  yyt->Kind = kConst_or_routine0;
  960.  yyt->yyHead.yyMark = 0;
  961.  return yyt;
  962. }
  963.  
  964. tTree nM_const () {
  965.  register tTree yyt;
  966.  yyALLOC (yyt, Tree_NodeSize [kM_const])
  967.  yyt->Kind = kM_const;
  968.  yyt->yyHead.yyMark = 0;
  969.  begintTree(yyt->M_const.Manifest_constant)
  970.  return yyt;
  971. }
  972.  
  973. tTree nUnique () {
  974.  register tTree yyt;
  975.  yyALLOC (yyt, Tree_NodeSize [kUnique])
  976.  yyt->Kind = kUnique;
  977.  yyt->yyHead.yyMark = 0;
  978.  begintPosition(yyt->Unique.pos)
  979.  return yyt;
  980. }
  981.  
  982. tTree nRoutine () {
  983.  register tTree yyt;
  984.  yyALLOC (yyt, Tree_NodeSize [kRoutine])
  985.  yyt->Kind = kRoutine;
  986.  yyt->yyHead.yyMark = 0;
  987.  begintTree(yyt->Routine.Obsolete)
  988.  begintStringRef(yyt->Routine.comment)
  989.  begintTree(yyt->Routine.Precondition)
  990.  begintTree(yyt->Routine.Local_decls)
  991.  begintTree(yyt->Routine.Routine_body)
  992.  begintTree(yyt->Routine.Postcondition)
  993.  begintTree(yyt->Routine.Rescue)
  994.  begintStringRef(yyt->Routine.end_comment)
  995.  return yyt;
  996. }
  997.  
  998. tTree nParent_list () {
  999.  register tTree yyt;
  1000.  yyALLOC (yyt, Tree_NodeSize [kParent_list])
  1001.  yyt->Kind = kParent_list;
  1002.  yyt->yyHead.yyMark = 0;
  1003.  return yyt;
  1004. }
  1005.  
  1006. tTree nParent_list0 () {
  1007.  register tTree yyt;
  1008.  yyALLOC (yyt, Tree_NodeSize [kParent_list0])
  1009.  yyt->Kind = kParent_list0;
  1010.  yyt->yyHead.yyMark = 0;
  1011.  return yyt;
  1012. }
  1013.  
  1014. tTree nParent_list1 () {
  1015.  register tTree yyt;
  1016.  yyALLOC (yyt, Tree_NodeSize [kParent_list1])
  1017.  yyt->Kind = kParent_list1;
  1018.  yyt->yyHead.yyMark = 0;
  1019.  begintTree(yyt->Parent_list1.Parent)
  1020.  begintTree(yyt->Parent_list1.Parent_list)
  1021.  return yyt;
  1022. }
  1023.  
  1024. tTree nParent () {
  1025.  register tTree yyt;
  1026.  yyALLOC (yyt, Tree_NodeSize [kParent])
  1027.  yyt->Kind = kParent;
  1028.  yyt->yyHead.yyMark = 0;
  1029.  begintTree(yyt->Parent.Class_type)
  1030.  begintTree(yyt->Parent.Feature_adaptation)
  1031.  return yyt;
  1032. }
  1033.  
  1034. tTree nFeature_adaptation () {
  1035.  register tTree yyt;
  1036.  yyALLOC (yyt, Tree_NodeSize [kFeature_adaptation])
  1037.  yyt->Kind = kFeature_adaptation;
  1038.  yyt->yyHead.yyMark = 0;
  1039.  return yyt;
  1040. }
  1041.  
  1042. tTree nFeature_adaptation0 () {
  1043.  register tTree yyt;
  1044.  yyALLOC (yyt, Tree_NodeSize [kFeature_adaptation0])
  1045.  yyt->Kind = kFeature_adaptation0;
  1046.  yyt->yyHead.yyMark = 0;
  1047.  return yyt;
  1048. }
  1049.  
  1050. tTree nFeature_adaptation1 () {
  1051.  register tTree yyt;
  1052.  yyALLOC (yyt, Tree_NodeSize [kFeature_adaptation1])
  1053.  yyt->Kind = kFeature_adaptation1;
  1054.  yyt->yyHead.yyMark = 0;
  1055.  begintTree(yyt->Feature_adaptation1.Rename)
  1056.  begintTree(yyt->Feature_adaptation1.New_export)
  1057.  begintTree(yyt->Feature_adaptation1.Undefine)
  1058.  begintTree(yyt->Feature_adaptation1.Redefine)
  1059.  begintTree(yyt->Feature_adaptation1.Select)
  1060.  return yyt;
  1061. }
  1062.  
  1063. tTree nRename_list () {
  1064.  register tTree yyt;
  1065.  yyALLOC (yyt, Tree_NodeSize [kRename_list])
  1066.  yyt->Kind = kRename_list;
  1067.  yyt->yyHead.yyMark = 0;
  1068.  return yyt;
  1069. }
  1070.  
  1071. tTree nRename_list0 () {
  1072.  register tTree yyt;
  1073.  yyALLOC (yyt, Tree_NodeSize [kRename_list0])
  1074.  yyt->Kind = kRename_list0;
  1075.  yyt->yyHead.yyMark = 0;
  1076.  return yyt;
  1077. }
  1078.  
  1079. tTree nRename_list1 () {
  1080.  register tTree yyt;
  1081.  yyALLOC (yyt, Tree_NodeSize [kRename_list1])
  1082.  yyt->Kind = kRename_list1;
  1083.  yyt->yyHead.yyMark = 0;
  1084.  begintTree(yyt->Rename_list1.Rename_pair)
  1085.  begintTree(yyt->Rename_list1.Rename_list)
  1086.  return yyt;
  1087. }
  1088.  
  1089. tTree nRename_pair () {
  1090.  register tTree yyt;
  1091.  yyALLOC (yyt, Tree_NodeSize [kRename_pair])
  1092.  yyt->Kind = kRename_pair;
  1093.  yyt->yyHead.yyMark = 0;
  1094.  begintTree(yyt->Rename_pair.Name1)
  1095.  begintTree(yyt->Rename_pair.Name2)
  1096.  return yyt;
  1097. }
  1098.  
  1099. tTree nCreators () {
  1100.  register tTree yyt;
  1101.  yyALLOC (yyt, Tree_NodeSize [kCreators])
  1102.  yyt->Kind = kCreators;
  1103.  yyt->yyHead.yyMark = 0;
  1104.  return yyt;
  1105. }
  1106.  
  1107. tTree nCreators0 () {
  1108.  register tTree yyt;
  1109.  yyALLOC (yyt, Tree_NodeSize [kCreators0])
  1110.  yyt->Kind = kCreators0;
  1111.  yyt->yyHead.yyMark = 0;
  1112.  return yyt;
  1113. }
  1114.  
  1115. tTree nCreators1 () {
  1116.  register tTree yyt;
  1117.  yyALLOC (yyt, Tree_NodeSize [kCreators1])
  1118.  yyt->Kind = kCreators1;
  1119.  yyt->yyHead.yyMark = 0;
  1120.  begintTree(yyt->Creators1.Creation_clause)
  1121.  begintTree(yyt->Creators1.Creators)
  1122.  return yyt;
  1123. }
  1124.  
  1125. tTree nCreation_clause () {
  1126.  register tTree yyt;
  1127.  yyALLOC (yyt, Tree_NodeSize [kCreation_clause])
  1128.  yyt->Kind = kCreation_clause;
  1129.  yyt->yyHead.yyMark = 0;
  1130.  begintTree(yyt->Creation_clause.Clients)
  1131.  begintStringRef(yyt->Creation_clause.comment)
  1132.  begintTree(yyt->Creation_clause.Feature_list)
  1133.  return yyt;
  1134. }
  1135.  
  1136. tTree nNew_feature_list () {
  1137.  register tTree yyt;
  1138.  yyALLOC (yyt, Tree_NodeSize [kNew_feature_list])
  1139.  yyt->Kind = kNew_feature_list;
  1140.  yyt->yyHead.yyMark = 0;
  1141.  return yyt;
  1142. }
  1143.  
  1144. tTree nNew_feature_list0 () {
  1145.  register tTree yyt;
  1146.  yyALLOC (yyt, Tree_NodeSize [kNew_feature_list0])
  1147.  yyt->Kind = kNew_feature_list0;
  1148.  yyt->yyHead.yyMark = 0;
  1149.  return yyt;
  1150. }
  1151.  
  1152. tTree nNew_feature_list1 () {
  1153.  register tTree yyt;
  1154.  yyALLOC (yyt, Tree_NodeSize [kNew_feature_list1])
  1155.  yyt->Kind = kNew_feature_list1;
  1156.  yyt->yyHead.yyMark = 0;
  1157.  begintTree(yyt->New_feature_list1.Feature_name)
  1158.  begintTree(yyt->New_feature_list1.New_feature_list)
  1159.  return yyt;
  1160. }
  1161.  
  1162. tTree nFeature_name () {
  1163.  register tTree yyt;
  1164.  yyALLOC (yyt, Tree_NodeSize [kFeature_name])
  1165.  yyt->Kind = kFeature_name;
  1166.  yyt->yyHead.yyMark = 0;
  1167.  return yyt;
  1168. }
  1169.  
  1170. tTree nFrozen () {
  1171.  register tTree yyt;
  1172.  yyALLOC (yyt, Tree_NodeSize [kFrozen])
  1173.  yyt->Kind = kFrozen;
  1174.  yyt->yyHead.yyMark = 0;
  1175.  begintTree(yyt->Frozen.Feature_name)
  1176.  return yyt;
  1177. }
  1178.  
  1179. tTree nIdent_name () {
  1180.  register tTree yyt;
  1181.  yyALLOC (yyt, Tree_NodeSize [kIdent_name])
  1182.  yyt->Kind = kIdent_name;
  1183.  yyt->yyHead.yyMark = 0;
  1184.  begintTree(yyt->Ident_name.Id)
  1185.  return yyt;
  1186. }
  1187.  
  1188. tTree nOp () {
  1189.  register tTree yyt;
  1190.  yyALLOC (yyt, Tree_NodeSize [kOp])
  1191.  yyt->Kind = kOp;
  1192.  yyt->yyHead.yyMark = 0;
  1193.  return yyt;
  1194. }
  1195.  
  1196. tTree nPrefix () {
  1197.  register tTree yyt;
  1198.  yyALLOC (yyt, Tree_NodeSize [kPrefix])
  1199.  yyt->Kind = kPrefix;
  1200.  yyt->yyHead.yyMark = 0;
  1201.  begintTree(yyt->Prefix.Op_name)
  1202.  return yyt;
  1203. }
  1204.  
  1205. tTree nInfix () {
  1206.  register tTree yyt;
  1207.  yyALLOC (yyt, Tree_NodeSize [kInfix])
  1208.  yyt->Kind = kInfix;
  1209.  yyt->yyHead.yyMark = 0;
  1210.  begintTree(yyt->Infix.Op_name)
  1211.  return yyt;
  1212. }
  1213.  
  1214. tTree nOp_name () {
  1215.  register tTree yyt;
  1216.  yyALLOC (yyt, Tree_NodeSize [kOp_name])
  1217.  yyt->Kind = kOp_name;
  1218.  yyt->yyHead.yyMark = 0;
  1219.  begintPosition(yyt->Op_name.pos)
  1220.  return yyt;
  1221. }
  1222.  
  1223. tTree nFree_op () {
  1224.  register tTree yyt;
  1225.  yyALLOC (yyt, Tree_NodeSize [kFree_op])
  1226.  yyt->Kind = kFree_op;
  1227.  yyt->yyHead.yyMark = 0;
  1228.  begintPosition(yyt->Free_op.pos)
  1229.  begintIdent(yyt->Free_op.ident)
  1230.  return yyt;
  1231. }
  1232.  
  1233. tTree nOper () {
  1234.  register tTree yyt;
  1235.  yyALLOC (yyt, Tree_NodeSize [kOper])
  1236.  yyt->Kind = kOper;
  1237.  yyt->yyHead.yyMark = 0;
  1238.  begintPosition(yyt->Oper.pos)
  1239.  beginint(yyt->Oper.op)
  1240.  return yyt;
  1241. }
  1242.  
  1243. tTree nNew_export_list () {
  1244.  register tTree yyt;
  1245.  yyALLOC (yyt, Tree_NodeSize [kNew_export_list])
  1246.  yyt->Kind = kNew_export_list;
  1247.  yyt->yyHead.yyMark = 0;
  1248.  return yyt;
  1249. }
  1250.  
  1251. tTree nNew_export_list0 () {
  1252.  register tTree yyt;
  1253.  yyALLOC (yyt, Tree_NodeSize [kNew_export_list0])
  1254.  yyt->Kind = kNew_export_list0;
  1255.  yyt->yyHead.yyMark = 0;
  1256.  return yyt;
  1257. }
  1258.  
  1259. tTree nNew_export_list1 () {
  1260.  register tTree yyt;
  1261.  yyALLOC (yyt, Tree_NodeSize [kNew_export_list1])
  1262.  yyt->Kind = kNew_export_list1;
  1263.  yyt->yyHead.yyMark = 0;
  1264.  begintTree(yyt->New_export_list1.New_export_item)
  1265.  begintTree(yyt->New_export_list1.New_export_list)
  1266.  return yyt;
  1267. }
  1268.  
  1269. tTree nNew_export_item () {
  1270.  register tTree yyt;
  1271.  yyALLOC (yyt, Tree_NodeSize [kNew_export_item])
  1272.  yyt->Kind = kNew_export_item;
  1273.  yyt->yyHead.yyMark = 0;
  1274.  begintTree(yyt->New_export_item.Clients)
  1275.  begintTree(yyt->New_export_item.Feature_set)
  1276.  return yyt;
  1277. }
  1278.  
  1279. tTree nFeature_list () {
  1280.  register tTree yyt;
  1281.  yyALLOC (yyt, Tree_NodeSize [kFeature_list])
  1282.  yyt->Kind = kFeature_list;
  1283.  yyt->yyHead.yyMark = 0;
  1284.  return yyt;
  1285. }
  1286.  
  1287. tTree nAll () {
  1288.  register tTree yyt;
  1289.  yyALLOC (yyt, Tree_NodeSize [kAll])
  1290.  yyt->Kind = kAll;
  1291.  yyt->yyHead.yyMark = 0;
  1292.  return yyt;
  1293. }
  1294.  
  1295. tTree nFeature_list0 () {
  1296.  register tTree yyt;
  1297.  yyALLOC (yyt, Tree_NodeSize [kFeature_list0])
  1298.  yyt->Kind = kFeature_list0;
  1299.  yyt->yyHead.yyMark = 0;
  1300.  return yyt;
  1301. }
  1302.  
  1303. tTree nFeature_list1 () {
  1304.  register tTree yyt;
  1305.  yyALLOC (yyt, Tree_NodeSize [kFeature_list1])
  1306.  yyt->Kind = kFeature_list1;
  1307.  yyt->yyHead.yyMark = 0;
  1308.  begintTree(yyt->Feature_list1.Feature_name)
  1309.  begintTree(yyt->Feature_list1.Feature_list)
  1310.  return yyt;
  1311. }
  1312.  
  1313. tTree nFormal_args () {
  1314.  register tTree yyt;
  1315.  yyALLOC (yyt, Tree_NodeSize [kFormal_args])
  1316.  yyt->Kind = kFormal_args;
  1317.  yyt->yyHead.yyMark = 0;
  1318.  return yyt;
  1319. }
  1320.  
  1321. tTree nFormal_args0 () {
  1322.  register tTree yyt;
  1323.  yyALLOC (yyt, Tree_NodeSize [kFormal_args0])
  1324.  yyt->Kind = kFormal_args0;
  1325.  yyt->yyHead.yyMark = 0;
  1326.  return yyt;
  1327. }
  1328.  
  1329. tTree nFormal_args1 () {
  1330.  register tTree yyt;
  1331.  yyALLOC (yyt, Tree_NodeSize [kFormal_args1])
  1332.  yyt->Kind = kFormal_args1;
  1333.  yyt->yyHead.yyMark = 0;
  1334.  begintTree(yyt->Formal_args1.Entity_decl_group)
  1335.  begintTree(yyt->Formal_args1.Formal_args)
  1336.  return yyt;
  1337. }
  1338.  
  1339. tTree nRoutine_body () {
  1340.  register tTree yyt;
  1341.  yyALLOC (yyt, Tree_NodeSize [kRoutine_body])
  1342.  yyt->Kind = kRoutine_body;
  1343.  yyt->yyHead.yyMark = 0;
  1344.  return yyt;
  1345. }
  1346.  
  1347. tTree nRoutine_body0 () {
  1348.  register tTree yyt;
  1349.  yyALLOC (yyt, Tree_NodeSize [kRoutine_body0])
  1350.  yyt->Kind = kRoutine_body0;
  1351.  yyt->yyHead.yyMark = 0;
  1352.  return yyt;
  1353. }
  1354.  
  1355. tTree nEffective () {
  1356.  register tTree yyt;
  1357.  yyALLOC (yyt, Tree_NodeSize [kEffective])
  1358.  yyt->Kind = kEffective;
  1359.  yyt->yyHead.yyMark = 0;
  1360.  return yyt;
  1361. }
  1362.  
  1363. tTree nInternal () {
  1364.  register tTree yyt;
  1365.  yyALLOC (yyt, Tree_NodeSize [kInternal])
  1366.  yyt->Kind = kInternal;
  1367.  yyt->yyHead.yyMark = 0;
  1368.  return yyt;
  1369. }
  1370.  
  1371. tTree nDo_body () {
  1372.  register tTree yyt;
  1373.  yyALLOC (yyt, Tree_NodeSize [kDo_body])
  1374.  yyt->Kind = kDo_body;
  1375.  yyt->yyHead.yyMark = 0;
  1376.  begintTree(yyt->Do_body.Compound)
  1377.  return yyt;
  1378. }
  1379.  
  1380. tTree nOnce_body () {
  1381.  register tTree yyt;
  1382.  yyALLOC (yyt, Tree_NodeSize [kOnce_body])
  1383.  yyt->Kind = kOnce_body;
  1384.  yyt->yyHead.yyMark = 0;
  1385.  begintTree(yyt->Once_body.Compound)
  1386.  return yyt;
  1387. }
  1388.  
  1389. tTree nExternal () {
  1390.  register tTree yyt;
  1391.  yyALLOC (yyt, Tree_NodeSize [kExternal])
  1392.  yyt->Kind = kExternal;
  1393.  yyt->yyHead.yyMark = 0;
  1394.  begintTree(yyt->External.Lang1)
  1395.  begintTree(yyt->External.Lang2)
  1396.  return yyt;
  1397. }
  1398.  
  1399. tTree nDeferred () {
  1400.  register tTree yyt;
  1401.  yyALLOC (yyt, Tree_NodeSize [kDeferred])
  1402.  yyt->Kind = kDeferred;
  1403.  yyt->yyHead.yyMark = 0;
  1404.  begintPosition(yyt->Deferred.pos)
  1405.  return yyt;
  1406. }
  1407.  
  1408. tTree nEntity_decl_group () {
  1409.  register tTree yyt;
  1410.  yyALLOC (yyt, Tree_NodeSize [kEntity_decl_group])
  1411.  yyt->Kind = kEntity_decl_group;
  1412.  yyt->yyHead.yyMark = 0;
  1413.  begintTree(yyt->Entity_decl_group.Id_list)
  1414.  begintTree(yyt->Entity_decl_group.Type_mark)
  1415.  return yyt;
  1416. }
  1417.  
  1418. tTree nFormal_generics () {
  1419.  register tTree yyt;
  1420.  yyALLOC (yyt, Tree_NodeSize [kFormal_generics])
  1421.  yyt->Kind = kFormal_generics;
  1422.  yyt->yyHead.yyMark = 0;
  1423.  return yyt;
  1424. }
  1425.  
  1426. tTree nFormal_generics0 () {
  1427.  register tTree yyt;
  1428.  yyALLOC (yyt, Tree_NodeSize [kFormal_generics0])
  1429.  yyt->Kind = kFormal_generics0;
  1430.  yyt->yyHead.yyMark = 0;
  1431.  return yyt;
  1432. }
  1433.  
  1434. tTree nFormal_generics1 () {
  1435.  register tTree yyt;
  1436.  yyALLOC (yyt, Tree_NodeSize [kFormal_generics1])
  1437.  yyt->Kind = kFormal_generics1;
  1438.  yyt->yyHead.yyMark = 0;
  1439.  begintTree(yyt->Formal_generics1.Formal_generic)
  1440.  begintTree(yyt->Formal_generics1.Formal_generics)
  1441.  return yyt;
  1442. }
  1443.  
  1444. tTree nFormal_generic () {
  1445.  register tTree yyt;
  1446.  yyALLOC (yyt, Tree_NodeSize [kFormal_generic])
  1447.  yyt->Kind = kFormal_generic;
  1448.  yyt->yyHead.yyMark = 0;
  1449.  begintTree(yyt->Formal_generic.Id)
  1450.  begintTree(yyt->Formal_generic.Constraint)
  1451.  return yyt;
  1452. }
  1453.  
  1454. tTree nConstraint () {
  1455.  register tTree yyt;
  1456.  yyALLOC (yyt, Tree_NodeSize [kConstraint])
  1457.  yyt->Kind = kConstraint;
  1458.  yyt->yyHead.yyMark = 0;
  1459.  return yyt;
  1460. }
  1461.  
  1462. tTree nConstraint0 () {
  1463.  register tTree yyt;
  1464.  yyALLOC (yyt, Tree_NodeSize [kConstraint0])
  1465.  yyt->Kind = kConstraint0;
  1466.  yyt->yyHead.yyMark = 0;
  1467.  return yyt;
  1468. }
  1469.  
  1470. tTree nConstraint1 () {
  1471.  register tTree yyt;
  1472.  yyALLOC (yyt, Tree_NodeSize [kConstraint1])
  1473.  yyt->Kind = kConstraint1;
  1474.  yyt->yyHead.yyMark = 0;
  1475.  begintTree(yyt->Constraint1.Class_type)
  1476.  return yyt;
  1477. }
  1478.  
  1479. tTree nCompound () {
  1480.  register tTree yyt;
  1481.  yyALLOC (yyt, Tree_NodeSize [kCompound])
  1482.  yyt->Kind = kCompound;
  1483.  yyt->yyHead.yyMark = 0;
  1484.  return yyt;
  1485. }
  1486.  
  1487. tTree nCompound0 () {
  1488.  register tTree yyt;
  1489.  yyALLOC (yyt, Tree_NodeSize [kCompound0])
  1490.  yyt->Kind = kCompound0;
  1491.  yyt->yyHead.yyMark = 0;
  1492.  return yyt;
  1493. }
  1494.  
  1495. tTree nCompound1 () {
  1496.  register tTree yyt;
  1497.  yyALLOC (yyt, Tree_NodeSize [kCompound1])
  1498.  yyt->Kind = kCompound1;
  1499.  yyt->yyHead.yyMark = 0;
  1500.  begintTree(yyt->Compound1.Instruction)
  1501.  begintTree(yyt->Compound1.Compound)
  1502.  return yyt;
  1503. }
  1504.  
  1505. tTree nThen_part_list () {
  1506.  register tTree yyt;
  1507.  yyALLOC (yyt, Tree_NodeSize [kThen_part_list])
  1508.  yyt->Kind = kThen_part_list;
  1509.  yyt->yyHead.yyMark = 0;
  1510.  return yyt;
  1511. }
  1512.  
  1513. tTree nThen_part_list0 () {
  1514.  register tTree yyt;
  1515.  yyALLOC (yyt, Tree_NodeSize [kThen_part_list0])
  1516.  yyt->Kind = kThen_part_list0;
  1517.  yyt->yyHead.yyMark = 0;
  1518.  return yyt;
  1519. }
  1520.  
  1521. tTree nThen_part_list1 () {
  1522.  register tTree yyt;
  1523.  yyALLOC (yyt, Tree_NodeSize [kThen_part_list1])
  1524.  yyt->Kind = kThen_part_list1;
  1525.  yyt->yyHead.yyMark = 0;
  1526.  begintTree(yyt->Then_part_list1.Then_part)
  1527.  begintTree(yyt->Then_part_list1.Then_part_list)
  1528.  return yyt;
  1529. }
  1530.  
  1531. tTree nThen_part () {
  1532.  register tTree yyt;
  1533.  yyALLOC (yyt, Tree_NodeSize [kThen_part])
  1534.  yyt->Kind = kThen_part;
  1535.  yyt->yyHead.yyMark = 0;
  1536.  begintTree(yyt->Then_part.Guard)
  1537.  begintTree(yyt->Then_part.Compound)
  1538.  return yyt;
  1539. }
  1540.  
  1541. tTree nWhen_part_list () {
  1542.  register tTree yyt;
  1543.  yyALLOC (yyt, Tree_NodeSize [kWhen_part_list])
  1544.  yyt->Kind = kWhen_part_list;
  1545.  yyt->yyHead.yyMark = 0;
  1546.  return yyt;
  1547. }
  1548.  
  1549. tTree nWhen_part_list0 () {
  1550.  register tTree yyt;
  1551.  yyALLOC (yyt, Tree_NodeSize [kWhen_part_list0])
  1552.  yyt->Kind = kWhen_part_list0;
  1553.  yyt->yyHead.yyMark = 0;
  1554.  return yyt;
  1555. }
  1556.  
  1557. tTree nWhen_part_list1 () {
  1558.  register tTree yyt;
  1559.  yyALLOC (yyt, Tree_NodeSize [kWhen_part_list1])
  1560.  yyt->Kind = kWhen_part_list1;
  1561.  yyt->yyHead.yyMark = 0;
  1562.  begintTree(yyt->When_part_list1.When_part)
  1563.  begintTree(yyt->When_part_list1.When_part_list)
  1564.  return yyt;
  1565. }
  1566.  
  1567. tTree nWhen_part () {
  1568.  register tTree yyt;
  1569.  yyALLOC (yyt, Tree_NodeSize [kWhen_part])
  1570.  yyt->Kind = kWhen_part;
  1571.  yyt->yyHead.yyMark = 0;
  1572.  begintTree(yyt->When_part.Choices)
  1573.  begintTree(yyt->When_part.Compound)
  1574.  return yyt;
  1575. }
  1576.  
  1577. tTree nChoices () {
  1578.  register tTree yyt;
  1579.  yyALLOC (yyt, Tree_NodeSize [kChoices])
  1580.  yyt->Kind = kChoices;
  1581.  yyt->yyHead.yyMark = 0;
  1582.  return yyt;
  1583. }
  1584.  
  1585. tTree nChoices0 () {
  1586.  register tTree yyt;
  1587.  yyALLOC (yyt, Tree_NodeSize [kChoices0])
  1588.  yyt->Kind = kChoices0;
  1589.  yyt->yyHead.yyMark = 0;
  1590.  return yyt;
  1591. }
  1592.  
  1593. tTree nChoices1 () {
  1594.  register tTree yyt;
  1595.  yyALLOC (yyt, Tree_NodeSize [kChoices1])
  1596.  yyt->Kind = kChoices1;
  1597.  yyt->yyHead.yyMark = 0;
  1598.  begintTree(yyt->Choices1.Choice)
  1599.  begintTree(yyt->Choices1.Choices)
  1600.  return yyt;
  1601. }
  1602.  
  1603. tTree nChoice () {
  1604.  register tTree yyt;
  1605.  yyALLOC (yyt, Tree_NodeSize [kChoice])
  1606.  yyt->Kind = kChoice;
  1607.  yyt->yyHead.yyMark = 0;
  1608.  return yyt;
  1609. }
  1610.  
  1611. tTree nInterval () {
  1612.  register tTree yyt;
  1613.  yyALLOC (yyt, Tree_NodeSize [kInterval])
  1614.  yyt->Kind = kInterval;
  1615.  yyt->yyHead.yyMark = 0;
  1616.  begintTree(yyt->Interval.From)
  1617.  begintTree(yyt->Interval.To)
  1618.  return yyt;
  1619. }
  1620.  
  1621. tTree nVal () {
  1622.  register tTree yyt;
  1623.  yyALLOC (yyt, Tree_NodeSize [kVal])
  1624.  yyt->Kind = kVal;
  1625.  yyt->yyHead.yyMark = 0;
  1626.  begintTree(yyt->Val.Manifest_constant)
  1627.  return yyt;
  1628. }
  1629.  
  1630. tTree nInstruction () {
  1631.  register tTree yyt;
  1632.  yyALLOC (yyt, Tree_NodeSize [kInstruction])
  1633.  yyt->Kind = kInstruction;
  1634.  yyt->yyHead.yyMark = 0;
  1635.  return yyt;
  1636. }
  1637.  
  1638. tTree nInstruction0 () {
  1639.  register tTree yyt;
  1640.  yyALLOC (yyt, Tree_NodeSize [kInstruction0])
  1641.  yyt->Kind = kInstruction0;
  1642.  yyt->yyHead.yyMark = 0;
  1643.  return yyt;
  1644. }
  1645.  
  1646. tTree nCreation () {
  1647.  register tTree yyt;
  1648.  yyALLOC (yyt, Tree_NodeSize [kCreation])
  1649.  yyt->Kind = kCreation;
  1650.  yyt->yyHead.yyMark = 0;
  1651.  begintTree(yyt->Creation.Type)
  1652.  begintTree(yyt->Creation.Entity)
  1653.  begintTree(yyt->Creation.Unqual_call)
  1654.  return yyt;
  1655. }
  1656.  
  1657. tTree nCall_instruct () {
  1658.  register tTree yyt;
  1659.  yyALLOC (yyt, Tree_NodeSize [kCall_instruct])
  1660.  yyt->Kind = kCall_instruct;
  1661.  yyt->yyHead.yyMark = 0;
  1662.  begintTree(yyt->Call_instruct.Call)
  1663.  return yyt;
  1664. }
  1665.  
  1666. tTree nAssign () {
  1667.  register tTree yyt;
  1668.  yyALLOC (yyt, Tree_NodeSize [kAssign])
  1669.  yyt->Kind = kAssign;
  1670.  yyt->yyHead.yyMark = 0;
  1671.  begintTree(yyt->Assign.Addr)
  1672.  begintTree(yyt->Assign.Expression)
  1673.  return yyt;
  1674. }
  1675.  
  1676. tTree nRev_assign () {
  1677.  register tTree yyt;
  1678.  yyALLOC (yyt, Tree_NodeSize [kRev_assign])
  1679.  yyt->Kind = kRev_assign;
  1680.  yyt->yyHead.yyMark = 0;
  1681.  begintTree(yyt->Rev_assign.Addr)
  1682.  begintTree(yyt->Rev_assign.Expression)
  1683.  return yyt;
  1684. }
  1685.  
  1686. tTree nConditional () {
  1687.  register tTree yyt;
  1688.  yyALLOC (yyt, Tree_NodeSize [kConditional])
  1689.  yyt->Kind = kConditional;
  1690.  yyt->yyHead.yyMark = 0;
  1691.  begintTree(yyt->Conditional.Then_part)
  1692.  begintTree(yyt->Conditional.Else_part)
  1693.  return yyt;
  1694. }
  1695.  
  1696. tTree nMulti_branch () {
  1697.  register tTree yyt;
  1698.  yyALLOC (yyt, Tree_NodeSize [kMulti_branch])
  1699.  yyt->Kind = kMulti_branch;
  1700.  yyt->yyHead.yyMark = 0;
  1701.  begintTree(yyt->Multi_branch.Guard)
  1702.  begintTree(yyt->Multi_branch.When_part_list)
  1703.  begintTree(yyt->Multi_branch.Else_part)
  1704.  return yyt;
  1705. }
  1706.  
  1707. tTree nLoop () {
  1708.  register tTree yyt;
  1709.  yyALLOC (yyt, Tree_NodeSize [kLoop])
  1710.  yyt->Kind = kLoop;
  1711.  yyt->yyHead.yyMark = 0;
  1712.  begintTree(yyt->Loop.Initialization)
  1713.  begintTree(yyt->Loop.Invariant)
  1714.  begintTree(yyt->Loop.Variant)
  1715.  begintTree(yyt->Loop.Loop_body)
  1716.  return yyt;
  1717. }
  1718.  
  1719. tTree nCheck () {
  1720.  register tTree yyt;
  1721.  yyALLOC (yyt, Tree_NodeSize [kCheck])
  1722.  yyt->Kind = kCheck;
  1723.  yyt->yyHead.yyMark = 0;
  1724.  begintTree(yyt->Check.Assertion)
  1725.  return yyt;
  1726. }
  1727.  
  1728. tTree nDebug () {
  1729.  register tTree yyt;
  1730.  yyALLOC (yyt, Tree_NodeSize [kDebug])
  1731.  yyt->Kind = kDebug;
  1732.  yyt->yyHead.yyMark = 0;
  1733.  begintTree(yyt->Debug.Debug_keys)
  1734.  begintTree(yyt->Debug.Compound)
  1735.  return yyt;
  1736. }
  1737.  
  1738. tTree nRetry () {
  1739.  register tTree yyt;
  1740.  yyALLOC (yyt, Tree_NodeSize [kRetry])
  1741.  yyt->Kind = kRetry;
  1742.  yyt->yyHead.yyMark = 0;
  1743.  begintPosition(yyt->Retry.pos)
  1744.  return yyt;
  1745. }
  1746.  
  1747. tTree nLoop_body () {
  1748.  register tTree yyt;
  1749.  yyALLOC (yyt, Tree_NodeSize [kLoop_body])
  1750.  yyt->Kind = kLoop_body;
  1751.  yyt->yyHead.yyMark = 0;
  1752.  return yyt;
  1753. }
  1754.  
  1755. tTree nLoop_body0 () {
  1756.  register tTree yyt;
  1757.  yyALLOC (yyt, Tree_NodeSize [kLoop_body0])
  1758.  yyt->Kind = kLoop_body0;
  1759.  yyt->yyHead.yyMark = 0;
  1760.  return yyt;
  1761. }
  1762.  
  1763. tTree nLoop_body1 () {
  1764.  register tTree yyt;
  1765.  yyALLOC (yyt, Tree_NodeSize [kLoop_body1])
  1766.  yyt->Kind = kLoop_body1;
  1767.  yyt->yyHead.yyMark = 0;
  1768.  begintTree(yyt->Loop_body1.Exit)
  1769.  begintTree(yyt->Loop_body1.Compound)
  1770.  return yyt;
  1771. }
  1772.  
  1773. tTree nType () {
  1774.  register tTree yyt;
  1775.  yyALLOC (yyt, Tree_NodeSize [kType])
  1776.  yyt->Kind = kType;
  1777.  yyt->yyHead.yyMark = 0;
  1778.  return yyt;
  1779. }
  1780.  
  1781. tTree nType0 () {
  1782.  register tTree yyt;
  1783.  yyALLOC (yyt, Tree_NodeSize [kType0])
  1784.  yyt->Kind = kType0;
  1785.  yyt->yyHead.yyMark = 0;
  1786.  return yyt;
  1787. }
  1788.  
  1789. tTree nClass_type () {
  1790.  register tTree yyt;
  1791.  yyALLOC (yyt, Tree_NodeSize [kClass_type])
  1792.  yyt->Kind = kClass_type;
  1793.  yyt->yyHead.yyMark = 0;
  1794.  begintTree(yyt->Class_type.Id)
  1795.  begintTree(yyt->Class_type.Actual_generics)
  1796.  return yyt;
  1797. }
  1798.  
  1799. tTree nClass_type_expanded () {
  1800.  register tTree yyt;
  1801.  yyALLOC (yyt, Tree_NodeSize [kClass_type_expanded])
  1802.  yyt->Kind = kClass_type_expanded;
  1803.  yyt->yyHead.yyMark = 0;
  1804.  begintTree(yyt->Class_type_expanded.Id)
  1805.  begintTree(yyt->Class_type_expanded.Actual_generics)
  1806.  return yyt;
  1807. }
  1808.  
  1809. tTree nBit_type () {
  1810.  register tTree yyt;
  1811.  yyALLOC (yyt, Tree_NodeSize [kBit_type])
  1812.  yyt->Kind = kBit_type;
  1813.  yyt->yyHead.yyMark = 0;
  1814.  begintTree(yyt->Bit_type.Manifest_constant)
  1815.  return yyt;
  1816. }
  1817.  
  1818. tTree nSimple_type () {
  1819.  register tTree yyt;
  1820.  yyALLOC (yyt, Tree_NodeSize [kSimple_type])
  1821.  yyt->Kind = kSimple_type;
  1822.  yyt->yyHead.yyMark = 0;
  1823.  begintTree(yyt->Simple_type.Manifest_constant)
  1824.  return yyt;
  1825. }
  1826.  
  1827. tTree nAnchored () {
  1828.  register tTree yyt;
  1829.  yyALLOC (yyt, Tree_NodeSize [kAnchored])
  1830.  yyt->Kind = kAnchored;
  1831.  yyt->yyHead.yyMark = 0;
  1832.  begintTree(yyt->Anchored.Entity)
  1833.  return yyt;
  1834. }
  1835.  
  1836. tTree nActual_generics () {
  1837.  register tTree yyt;
  1838.  yyALLOC (yyt, Tree_NodeSize [kActual_generics])
  1839.  yyt->Kind = kActual_generics;
  1840.  yyt->yyHead.yyMark = 0;
  1841.  return yyt;
  1842. }
  1843.  
  1844. tTree nActual_generics0 () {
  1845.  register tTree yyt;
  1846.  yyALLOC (yyt, Tree_NodeSize [kActual_generics0])
  1847.  yyt->Kind = kActual_generics0;
  1848.  yyt->yyHead.yyMark = 0;
  1849.  return yyt;
  1850. }
  1851.  
  1852. tTree nActual_generics1 () {
  1853.  register tTree yyt;
  1854.  yyALLOC (yyt, Tree_NodeSize [kActual_generics1])
  1855.  yyt->Kind = kActual_generics1;
  1856.  yyt->yyHead.yyMark = 0;
  1857.  begintTree(yyt->Actual_generics1.Type_list)
  1858.  return yyt;
  1859. }
  1860.  
  1861. tTree nCondition () {
  1862.  register tTree yyt;
  1863.  yyALLOC (yyt, Tree_NodeSize [kCondition])
  1864.  yyt->Kind = kCondition;
  1865.  yyt->yyHead.yyMark = 0;
  1866.  return yyt;
  1867. }
  1868.  
  1869. tTree nCondition0 () {
  1870.  register tTree yyt;
  1871.  yyALLOC (yyt, Tree_NodeSize [kCondition0])
  1872.  yyt->Kind = kCondition0;
  1873.  yyt->yyHead.yyMark = 0;
  1874.  return yyt;
  1875. }
  1876.  
  1877. tTree nCondition1 () {
  1878.  register tTree yyt;
  1879.  yyALLOC (yyt, Tree_NodeSize [kCondition1])
  1880.  yyt->Kind = kCondition1;
  1881.  yyt->yyHead.yyMark = 0;
  1882.  beginint(yyt->Condition1.extension)
  1883.  begintTree(yyt->Condition1.Assertion)
  1884.  return yyt;
  1885. }
  1886.  
  1887. tTree nAssertion () {
  1888.  register tTree yyt;
  1889.  yyALLOC (yyt, Tree_NodeSize [kAssertion])
  1890.  yyt->Kind = kAssertion;
  1891.  yyt->yyHead.yyMark = 0;
  1892.  return yyt;
  1893. }
  1894.  
  1895. tTree nAssertion0 () {
  1896.  register tTree yyt;
  1897.  yyALLOC (yyt, Tree_NodeSize [kAssertion0])
  1898.  yyt->Kind = kAssertion0;
  1899.  yyt->yyHead.yyMark = 0;
  1900.  return yyt;
  1901. }
  1902.  
  1903. tTree nAssertion1 () {
  1904.  register tTree yyt;
  1905.  yyALLOC (yyt, Tree_NodeSize [kAssertion1])
  1906.  yyt->Kind = kAssertion1;
  1907.  yyt->yyHead.yyMark = 0;
  1908.  begintTree(yyt->Assertion1.Assertion_clause)
  1909.  begintTree(yyt->Assertion1.Assertion)
  1910.  return yyt;
  1911. }
  1912.  
  1913. tTree nAssertion_clause () {
  1914.  register tTree yyt;
  1915.  yyALLOC (yyt, Tree_NodeSize [kAssertion_clause])
  1916.  yyt->Kind = kAssertion_clause;
  1917.  yyt->yyHead.yyMark = 0;
  1918.  return yyt;
  1919. }
  1920.  
  1921. tTree nAssertion_clause0 () {
  1922.  register tTree yyt;
  1923.  yyALLOC (yyt, Tree_NodeSize [kAssertion_clause0])
  1924.  yyt->Kind = kAssertion_clause0;
  1925.  yyt->yyHead.yyMark = 0;
  1926.  return yyt;
  1927. }
  1928.  
  1929. tTree nAssertion_clause1 () {
  1930.  register tTree yyt;
  1931.  yyALLOC (yyt, Tree_NodeSize [kAssertion_clause1])
  1932.  yyt->Kind = kAssertion_clause1;
  1933.  yyt->yyHead.yyMark = 0;
  1934.  begintTree(yyt->Assertion_clause1.Tag)
  1935.  begintTree(yyt->Assertion_clause1.Expression)
  1936.  return yyt;
  1937. }
  1938.  
  1939. tTree nType_list () {
  1940.  register tTree yyt;
  1941.  yyALLOC (yyt, Tree_NodeSize [kType_list])
  1942.  yyt->Kind = kType_list;
  1943.  yyt->yyHead.yyMark = 0;
  1944.  return yyt;
  1945. }
  1946.  
  1947. tTree nType_list0 () {
  1948.  register tTree yyt;
  1949.  yyALLOC (yyt, Tree_NodeSize [kType_list0])
  1950.  yyt->Kind = kType_list0;
  1951.  yyt->yyHead.yyMark = 0;
  1952.  return yyt;
  1953. }
  1954.  
  1955. tTree nType_list1 () {
  1956.  register tTree yyt;
  1957.  yyALLOC (yyt, Tree_NodeSize [kType_list1])
  1958.  yyt->Kind = kType_list1;
  1959.  yyt->yyHead.yyMark = 0;
  1960.  begintTree(yyt->Type_list1.Type)
  1961.  begintTree(yyt->Type_list1.Type_list)
  1962.  return yyt;
  1963. }
  1964.  
  1965. tTree nCall_chain () {
  1966.  register tTree yyt;
  1967.  yyALLOC (yyt, Tree_NodeSize [kCall_chain])
  1968.  yyt->Kind = kCall_chain;
  1969.  yyt->yyHead.yyMark = 0;
  1970.  return yyt;
  1971. }
  1972.  
  1973. tTree nCall_chain0 () {
  1974.  register tTree yyt;
  1975.  yyALLOC (yyt, Tree_NodeSize [kCall_chain0])
  1976.  yyt->Kind = kCall_chain0;
  1977.  yyt->yyHead.yyMark = 0;
  1978.  return yyt;
  1979. }
  1980.  
  1981. tTree nCall_chain1 () {
  1982.  register tTree yyt;
  1983.  yyALLOC (yyt, Tree_NodeSize [kCall_chain1])
  1984.  yyt->Kind = kCall_chain1;
  1985.  yyt->yyHead.yyMark = 0;
  1986.  begintTree(yyt->Call_chain1.Unqual_call)
  1987.  begintTree(yyt->Call_chain1.Call_chain)
  1988.  return yyt;
  1989. }
  1990.  
  1991. tTree nUnqual_call () {
  1992.  register tTree yyt;
  1993.  yyALLOC (yyt, Tree_NodeSize [kUnqual_call])
  1994.  yyt->Kind = kUnqual_call;
  1995.  yyt->yyHead.yyMark = 0;
  1996.  return yyt;
  1997. }
  1998.  
  1999. tTree nUnqual_call0 () {
  2000.  register tTree yyt;
  2001.  yyALLOC (yyt, Tree_NodeSize [kUnqual_call0])
  2002.  yyt->Kind = kUnqual_call0;
  2003.  yyt->yyHead.yyMark = 0;
  2004.  return yyt;
  2005. }
  2006.  
  2007. tTree nUnqual_call1 () {
  2008.  register tTree yyt;
  2009.  yyALLOC (yyt, Tree_NodeSize [kUnqual_call1])
  2010.  yyt->Kind = kUnqual_call1;
  2011.  yyt->yyHead.yyMark = 0;
  2012.  begintTree(yyt->Unqual_call1.Entity)
  2013.  begintTree(yyt->Unqual_call1.Actuals)
  2014.  return yyt;
  2015. }
  2016.  
  2017. tTree nActuals () {
  2018.  register tTree yyt;
  2019.  yyALLOC (yyt, Tree_NodeSize [kActuals])
  2020.  yyt->Kind = kActuals;
  2021.  yyt->yyHead.yyMark = 0;
  2022.  return yyt;
  2023. }
  2024.  
  2025. tTree nActuals0 () {
  2026.  register tTree yyt;
  2027.  yyALLOC (yyt, Tree_NodeSize [kActuals0])
  2028.  yyt->Kind = kActuals0;
  2029.  yyt->yyHead.yyMark = 0;
  2030.  return yyt;
  2031. }
  2032.  
  2033. tTree nActuals1 () {
  2034.  register tTree yyt;
  2035.  yyALLOC (yyt, Tree_NodeSize [kActuals1])
  2036.  yyt->Kind = kActuals1;
  2037.  yyt->yyHead.yyMark = 0;
  2038.  begintTree(yyt->Actuals1.Actual_list)
  2039.  return yyt;
  2040. }
  2041.  
  2042. tTree nActual_list () {
  2043.  register tTree yyt;
  2044.  yyALLOC (yyt, Tree_NodeSize [kActual_list])
  2045.  yyt->Kind = kActual_list;
  2046.  yyt->yyHead.yyMark = 0;
  2047.  return yyt;
  2048. }
  2049.  
  2050. tTree nActual_list0 () {
  2051.  register tTree yyt;
  2052.  yyALLOC (yyt, Tree_NodeSize [kActual_list0])
  2053.  yyt->Kind = kActual_list0;
  2054.  yyt->yyHead.yyMark = 0;
  2055.  return yyt;
  2056. }
  2057.  
  2058. tTree nActual_list1 () {
  2059.  register tTree yyt;
  2060.  yyALLOC (yyt, Tree_NodeSize [kActual_list1])
  2061.  yyt->Kind = kActual_list1;
  2062.  yyt->yyHead.yyMark = 0;
  2063.  begintTree(yyt->Actual_list1.Actual)
  2064.  begintTree(yyt->Actual_list1.Actual_list)
  2065.  return yyt;
  2066. }
  2067.  
  2068. tTree nActual () {
  2069.  register tTree yyt;
  2070.  yyALLOC (yyt, Tree_NodeSize [kActual])
  2071.  yyt->Kind = kActual;
  2072.  yyt->yyHead.yyMark = 0;
  2073.  return yyt;
  2074. }
  2075.  
  2076. tTree nAddr () {
  2077.  register tTree yyt;
  2078.  yyALLOC (yyt, Tree_NodeSize [kAddr])
  2079.  yyt->Kind = kAddr;
  2080.  yyt->yyHead.yyMark = 0;
  2081.  begintTree(yyt->Addr.Entity)
  2082.  return yyt;
  2083. }
  2084.  
  2085. tTree nExpression () {
  2086.  register tTree yyt;
  2087.  yyALLOC (yyt, Tree_NodeSize [kExpression])
  2088.  yyt->Kind = kExpression;
  2089.  yyt->yyHead.yyMark = 0;
  2090.  return yyt;
  2091. }
  2092.  
  2093. tTree nExpression0 () {
  2094.  register tTree yyt;
  2095.  yyALLOC (yyt, Tree_NodeSize [kExpression0])
  2096.  yyt->Kind = kExpression0;
  2097.  yyt->yyHead.yyMark = 0;
  2098.  return yyt;
  2099. }
  2100.  
  2101. tTree nComment () {
  2102.  register tTree yyt;
  2103.  yyALLOC (yyt, Tree_NodeSize [kComment])
  2104.  yyt->Kind = kComment;
  2105.  yyt->yyHead.yyMark = 0;
  2106.  begintStringRef(yyt->Comment.comment)
  2107.  return yyt;
  2108. }
  2109.  
  2110. tTree nSimple_expr () {
  2111.  register tTree yyt;
  2112.  yyALLOC (yyt, Tree_NodeSize [kSimple_expr])
  2113.  yyt->Kind = kSimple_expr;
  2114.  yyt->yyHead.yyMark = 0;
  2115.  begintTree(yyt->Simple_expr.Manifest_constant)
  2116.  return yyt;
  2117. }
  2118.  
  2119. tTree nCall () {
  2120.  register tTree yyt;
  2121.  yyALLOC (yyt, Tree_NodeSize [kCall])
  2122.  yyt->Kind = kCall;
  2123.  yyt->yyHead.yyMark = 0;
  2124.  begintTree(yyt->Call.Qual)
  2125.  begintTree(yyt->Call.Call_chain)
  2126.  return yyt;
  2127. }
  2128.  
  2129. tTree nBin_expr () {
  2130.  register tTree yyt;
  2131.  yyALLOC (yyt, Tree_NodeSize [kBin_expr])
  2132.  yyt->Kind = kBin_expr;
  2133.  yyt->yyHead.yyMark = 0;
  2134.  begintTree(yyt->Bin_expr.Lop)
  2135.  begintTree(yyt->Bin_expr.Op)
  2136.  begintTree(yyt->Bin_expr.Rop)
  2137.  return yyt;
  2138. }
  2139.  
  2140. tTree nUn_expr () {
  2141.  register tTree yyt;
  2142.  yyALLOC (yyt, Tree_NodeSize [kUn_expr])
  2143.  yyt->Kind = kUn_expr;
  2144.  yyt->yyHead.yyMark = 0;
  2145.  begintTree(yyt->Un_expr.Op)
  2146.  begintTree(yyt->Un_expr.Expression)
  2147.  return yyt;
  2148. }
  2149.  
  2150. tTree nParenth () {
  2151.  register tTree yyt;
  2152.  yyALLOC (yyt, Tree_NodeSize [kParenth])
  2153.  yyt->Kind = kParenth;
  2154.  yyt->yyHead.yyMark = 0;
  2155.  begintTree(yyt->Parenth.Expression)
  2156.  return yyt;
  2157. }
  2158.  
  2159. tTree nManifest_array () {
  2160.  register tTree yyt;
  2161.  yyALLOC (yyt, Tree_NodeSize [kManifest_array])
  2162.  yyt->Kind = kManifest_array;
  2163.  yyt->yyHead.yyMark = 0;
  2164.  return yyt;
  2165. }
  2166.  
  2167. tTree nManifest_array0 () {
  2168.  register tTree yyt;
  2169.  yyALLOC (yyt, Tree_NodeSize [kManifest_array0])
  2170.  yyt->Kind = kManifest_array0;
  2171.  yyt->yyHead.yyMark = 0;
  2172.  return yyt;
  2173. }
  2174.  
  2175. tTree nManifest_array1 () {
  2176.  register tTree yyt;
  2177.  yyALLOC (yyt, Tree_NodeSize [kManifest_array1])
  2178.  yyt->Kind = kManifest_array1;
  2179.  yyt->yyHead.yyMark = 0;
  2180.  begintTree(yyt->Manifest_array1.Expression)
  2181.  begintTree(yyt->Manifest_array1.Manifest_array)
  2182.  return yyt;
  2183. }
  2184.  
  2185. tTree nOld () {
  2186.  register tTree yyt;
  2187.  yyALLOC (yyt, Tree_NodeSize [kOld])
  2188.  yyt->Kind = kOld;
  2189.  yyt->yyHead.yyMark = 0;
  2190.  begintTree(yyt->Old.Expression)
  2191.  return yyt;
  2192. }
  2193.  
  2194. tTree nStrip () {
  2195.  register tTree yyt;
  2196.  yyALLOC (yyt, Tree_NodeSize [kStrip])
  2197.  yyt->Kind = kStrip;
  2198.  yyt->yyHead.yyMark = 0;
  2199.  begintTree(yyt->Strip.List)
  2200.  return yyt;
  2201. }
  2202.  
  2203. tTree nList () {
  2204.  register tTree yyt;
  2205.  yyALLOC (yyt, Tree_NodeSize [kList])
  2206.  yyt->Kind = kList;
  2207.  yyt->yyHead.yyMark = 0;
  2208.  return yyt;
  2209. }
  2210.  
  2211. tTree nnolist () {
  2212.  register tTree yyt;
  2213.  yyALLOC (yyt, Tree_NodeSize [knolist])
  2214.  yyt->Kind = knolist;
  2215.  yyt->yyHead.yyMark = 0;
  2216.  return yyt;
  2217. }
  2218.  
  2219. tTree nlist () {
  2220.  register tTree yyt;
  2221.  yyALLOC (yyt, Tree_NodeSize [klist])
  2222.  yyt->Kind = klist;
  2223.  yyt->yyHead.yyMark = 0;
  2224.  begintTree(yyt->list.Manifest_constant)
  2225.  begintTree(yyt->list.List)
  2226.  return yyt;
  2227. }
  2228.  
  2229. tTree nManifest_constant () {
  2230.  register tTree yyt;
  2231.  yyALLOC (yyt, Tree_NodeSize [kManifest_constant])
  2232.  yyt->Kind = kManifest_constant;
  2233.  yyt->yyHead.yyMark = 0;
  2234.  return yyt;
  2235. }
  2236.  
  2237. tTree nManifest_constant0 () {
  2238.  register tTree yyt;
  2239.  yyALLOC (yyt, Tree_NodeSize [kManifest_constant0])
  2240.  yyt->Kind = kManifest_constant0;
  2241.  yyt->yyHead.yyMark = 0;
  2242.  return yyt;
  2243. }
  2244.  
  2245. tTree nCh () {
  2246.  register tTree yyt;
  2247.  yyALLOC (yyt, Tree_NodeSize [kCh])
  2248.  yyt->Kind = kCh;
  2249.  yyt->yyHead.yyMark = 0;
  2250.  beginint(yyt->Ch.ch)
  2251.  begintPosition(yyt->Ch.pos)
  2252.  return yyt;
  2253. }
  2254.  
  2255. tTree nTrue () {
  2256.  register tTree yyt;
  2257.  yyALLOC (yyt, Tree_NodeSize [kTrue])
  2258.  yyt->Kind = kTrue;
  2259.  yyt->yyHead.yyMark = 0;
  2260.  begintPosition(yyt->True.pos)
  2261.  return yyt;
  2262. }
  2263.  
  2264. tTree nFalse () {
  2265.  register tTree yyt;
  2266.  yyALLOC (yyt, Tree_NodeSize [kFalse])
  2267.  yyt->Kind = kFalse;
  2268.  yyt->yyHead.yyMark = 0;
  2269.  begintPosition(yyt->False.pos)
  2270.  return yyt;
  2271. }
  2272.  
  2273. tTree nInt () {
  2274.  register tTree yyt;
  2275.  yyALLOC (yyt, Tree_NodeSize [kInt])
  2276.  yyt->Kind = kInt;
  2277.  yyt->yyHead.yyMark = 0;
  2278.  begintTree(yyt->Int.Sign)
  2279.  beginlong(yyt->Int.value)
  2280.  begintPosition(yyt->Int.pos)
  2281.  return yyt;
  2282. }
  2283.  
  2284. tTree nReal () {
  2285.  register tTree yyt;
  2286.  yyALLOC (yyt, Tree_NodeSize [kReal])
  2287.  yyt->Kind = kReal;
  2288.  yyt->yyHead.yyMark = 0;
  2289.  begintTree(yyt->Real.Sign)
  2290.  begindouble(yyt->Real.value)
  2291.  begintPosition(yyt->Real.pos)
  2292.  return yyt;
  2293. }
  2294.  
  2295. tTree n_CHARACTER () {
  2296.  register tTree yyt;
  2297.  yyALLOC (yyt, Tree_NodeSize [k_CHARACTER])
  2298.  yyt->Kind = k_CHARACTER;
  2299.  yyt->yyHead.yyMark = 0;
  2300.  begintPosition(yyt->_CHARACTER.pos)
  2301.  return yyt;
  2302. }
  2303.  
  2304. tTree n_INTEGER () {
  2305.  register tTree yyt;
  2306.  yyALLOC (yyt, Tree_NodeSize [k_INTEGER])
  2307.  yyt->Kind = k_INTEGER;
  2308.  yyt->yyHead.yyMark = 0;
  2309.  begintPosition(yyt->_INTEGER.pos)
  2310.  return yyt;
  2311. }
  2312.  
  2313. tTree n_REAL () {
  2314.  register tTree yyt;
  2315.  yyALLOC (yyt, Tree_NodeSize [k_REAL])
  2316.  yyt->Kind = k_REAL;
  2317.  yyt->yyHead.yyMark = 0;
  2318.  begintPosition(yyt->_REAL.pos)
  2319.  return yyt;
  2320. }
  2321.  
  2322. tTree n_DOUBLE () {
  2323.  register tTree yyt;
  2324.  yyALLOC (yyt, Tree_NodeSize [k_DOUBLE])
  2325.  yyt->Kind = k_DOUBLE;
  2326.  yyt->yyHead.yyMark = 0;
  2327.  begintPosition(yyt->_DOUBLE.pos)
  2328.  return yyt;
  2329. }
  2330.  
  2331. tTree n_BOOLEAN () {
  2332.  register tTree yyt;
  2333.  yyALLOC (yyt, Tree_NodeSize [k_BOOLEAN])
  2334.  yyt->Kind = k_BOOLEAN;
  2335.  yyt->yyHead.yyMark = 0;
  2336.  begintPosition(yyt->_BOOLEAN.pos)
  2337.  return yyt;
  2338. }
  2339.  
  2340. tTree n_STRING () {
  2341.  register tTree yyt;
  2342.  yyALLOC (yyt, Tree_NodeSize [k_STRING])
  2343.  yyt->Kind = k_STRING;
  2344.  yyt->yyHead.yyMark = 0;
  2345.  begintPosition(yyt->_STRING.pos)
  2346.  return yyt;
  2347. }
  2348.  
  2349. tTree n_BIT () {
  2350.  register tTree yyt;
  2351.  yyALLOC (yyt, Tree_NodeSize [k_BIT])
  2352.  yyt->Kind = k_BIT;
  2353.  yyt->yyHead.yyMark = 0;
  2354.  begintPosition(yyt->_BIT.pos)
  2355.  return yyt;
  2356. }
  2357.  
  2358. tTree n_NONE () {
  2359.  register tTree yyt;
  2360.  yyALLOC (yyt, Tree_NodeSize [k_NONE])
  2361.  yyt->Kind = k_NONE;
  2362.  yyt->yyHead.yyMark = 0;
  2363.  begintPosition(yyt->_NONE.pos)
  2364.  return yyt;
  2365. }
  2366.  
  2367. tTree nBitseq () {
  2368.  register tTree yyt;
  2369.  yyALLOC (yyt, Tree_NodeSize [kBitseq])
  2370.  yyt->Kind = kBitseq;
  2371.  yyt->yyHead.yyMark = 0;
  2372.  begintStringRef(yyt->Bitseq.literal)
  2373.  begintPosition(yyt->Bitseq.pos)
  2374.  return yyt;
  2375. }
  2376.  
  2377. tTree nString () {
  2378.  register tTree yyt;
  2379.  yyALLOC (yyt, Tree_NodeSize [kString])
  2380.  yyt->Kind = kString;
  2381.  yyt->yyHead.yyMark = 0;
  2382.  begintStringRef(yyt->String.string)
  2383.  begintPosition(yyt->String.pos)
  2384.  return yyt;
  2385. }
  2386.  
  2387. tTree nString0 () {
  2388.  register tTree yyt;
  2389.  yyALLOC (yyt, Tree_NodeSize [kString0])
  2390.  yyt->Kind = kString0;
  2391.  yyt->yyHead.yyMark = 0;
  2392.  return yyt;
  2393. }
  2394.  
  2395. tTree nEntity () {
  2396.  register tTree yyt;
  2397.  yyALLOC (yyt, Tree_NodeSize [kEntity])
  2398.  yyt->Kind = kEntity;
  2399.  yyt->yyHead.yyMark = 0;
  2400.  return yyt;
  2401. }
  2402.  
  2403. tTree nEntity0 () {
  2404.  register tTree yyt;
  2405.  yyALLOC (yyt, Tree_NodeSize [kEntity0])
  2406.  yyt->Kind = kEntity0;
  2407.  yyt->yyHead.yyMark = 0;
  2408.  return yyt;
  2409. }
  2410.  
  2411. tTree nCurrent () {
  2412.  register tTree yyt;
  2413.  yyALLOC (yyt, Tree_NodeSize [kCurrent])
  2414.  yyt->Kind = kCurrent;
  2415.  yyt->yyHead.yyMark = 0;
  2416.  begintPosition(yyt->Current.pos)
  2417.  return yyt;
  2418. }
  2419.  
  2420. tTree nResult () {
  2421.  register tTree yyt;
  2422.  yyALLOC (yyt, Tree_NodeSize [kResult])
  2423.  yyt->Kind = kResult;
  2424.  yyt->yyHead.yyMark = 0;
  2425.  begintPosition(yyt->Result.pos)
  2426.  return yyt;
  2427. }
  2428.  
  2429. tTree nId () {
  2430.  register tTree yyt;
  2431.  yyALLOC (yyt, Tree_NodeSize [kId])
  2432.  yyt->Kind = kId;
  2433.  yyt->yyHead.yyMark = 0;
  2434.  begintIdent(yyt->Id.ident)
  2435.  begintPosition(yyt->Id.pos)
  2436.  return yyt;
  2437. }
  2438.  
  2439.  
  2440. tTree mEiffel
  2441. # if defined __STDC__ | defined __cplusplus
  2442. (tTree pClasses)
  2443. # else
  2444. (pClasses)
  2445. tTree pClasses;
  2446. # endif
  2447. {
  2448.  register tTree yyt;
  2449.  yyALLOC (yyt, Tree_NodeSize [kEiffel])
  2450.  yyt->Kind = kEiffel;
  2451.  yyt->yyHead.yyMark = 0;
  2452.  yyt->Eiffel.Classes = pClasses;
  2453.  return yyt;
  2454. }
  2455.  
  2456. tTree mClasses
  2457. # if defined __STDC__ | defined __cplusplus
  2458. ()
  2459. # else
  2460. ()
  2461. # endif
  2462. {
  2463.  register tTree yyt;
  2464.  yyALLOC (yyt, Tree_NodeSize [kClasses])
  2465.  yyt->Kind = kClasses;
  2466.  yyt->yyHead.yyMark = 0;
  2467.  return yyt;
  2468. }
  2469.  
  2470. tTree mClasses0
  2471. # if defined __STDC__ | defined __cplusplus
  2472. ()
  2473. # else
  2474. ()
  2475. # endif
  2476. {
  2477.  register tTree yyt;
  2478.  yyALLOC (yyt, Tree_NodeSize [kClasses0])
  2479.  yyt->Kind = kClasses0;
  2480.  yyt->yyHead.yyMark = 0;
  2481.  return yyt;
  2482. }
  2483.  
  2484. tTree mClasses1
  2485. # if defined __STDC__ | defined __cplusplus
  2486. (tTree pClass_declaration, tTree pClasses)
  2487. # else
  2488. (pClass_declaration, pClasses)
  2489. tTree pClass_declaration;
  2490. tTree pClasses;
  2491. # endif
  2492. {
  2493.  register tTree yyt;
  2494.  yyALLOC (yyt, Tree_NodeSize [kClasses1])
  2495.  yyt->Kind = kClasses1;
  2496.  yyt->yyHead.yyMark = 0;
  2497.  yyt->Classes1.Class_declaration = pClass_declaration;
  2498.  yyt->Classes1.Classes = pClasses;
  2499.  return yyt;
  2500. }
  2501.  
  2502. tTree mClass_declaration
  2503. # if defined __STDC__ | defined __cplusplus
  2504. (tTree pIndexing, tTree pClass_header, tTree pFormal_generics, tTree pObsolete, tTree pInheritance, tTree pCreators, tTree pFeatures, tTree pInvariant, tStringRef pcomment)
  2505. # else
  2506. (pIndexing, pClass_header, pFormal_generics, pObsolete, pInheritance, pCreators, pFeatures, pInvariant, pcomment)
  2507. tTree pIndexing;
  2508. tTree pClass_header;
  2509. tTree pFormal_generics;
  2510. tTree pObsolete;
  2511. tTree pInheritance;
  2512. tTree pCreators;
  2513. tTree pFeatures;
  2514. tTree pInvariant;
  2515. tStringRef pcomment;
  2516. # endif
  2517. {
  2518.  register tTree yyt;
  2519.  yyALLOC (yyt, Tree_NodeSize [kClass_declaration])
  2520.  yyt->Kind = kClass_declaration;
  2521.  yyt->yyHead.yyMark = 0;
  2522.  yyt->Class_declaration.Indexing = pIndexing;
  2523.  yyt->Class_declaration.Class_header = pClass_header;
  2524.  yyt->Class_declaration.Formal_generics = pFormal_generics;
  2525.  yyt->Class_declaration.Obsolete = pObsolete;
  2526.  yyt->Class_declaration.Inheritance = pInheritance;
  2527.  yyt->Class_declaration.Creators = pCreators;
  2528.  yyt->Class_declaration.Features = pFeatures;
  2529.  yyt->Class_declaration.Invariant = pInvariant;
  2530.  yyt->Class_declaration.comment = pcomment;
  2531.  return yyt;
  2532. }
  2533.  
  2534. tTree mIndex_list
  2535. # if defined __STDC__ | defined __cplusplus
  2536. ()
  2537. # else
  2538. ()
  2539. # endif
  2540. {
  2541.  register tTree yyt;
  2542.  yyALLOC (yyt, Tree_NodeSize [kIndex_list])
  2543.  yyt->Kind = kIndex_list;
  2544.  yyt->yyHead.yyMark = 0;
  2545.  return yyt;
  2546. }
  2547.  
  2548. tTree mIndex_list0
  2549. # if defined __STDC__ | defined __cplusplus
  2550. ()
  2551. # else
  2552. ()
  2553. # endif
  2554. {
  2555.  register tTree yyt;
  2556.  yyALLOC (yyt, Tree_NodeSize [kIndex_list0])
  2557.  yyt->Kind = kIndex_list0;
  2558.  yyt->yyHead.yyMark = 0;
  2559.  return yyt;
  2560. }
  2561.  
  2562. tTree mIndex_list1
  2563. # if defined __STDC__ | defined __cplusplus
  2564. (tTree pIndex_clause, tTree pIndex_list)
  2565. # else
  2566. (pIndex_clause, pIndex_list)
  2567. tTree pIndex_clause;
  2568. tTree pIndex_list;
  2569. # endif
  2570. {
  2571.  register tTree yyt;
  2572.  yyALLOC (yyt, Tree_NodeSize [kIndex_list1])
  2573.  yyt->Kind = kIndex_list1;
  2574.  yyt->yyHead.yyMark = 0;
  2575.  yyt->Index_list1.Index_clause = pIndex_clause;
  2576.  yyt->Index_list1.Index_list = pIndex_list;
  2577.  return yyt;
  2578. }
  2579.  
  2580. tTree mIndex_clause
  2581. # if defined __STDC__ | defined __cplusplus
  2582. (tTree pIndex, tTree pIndex_terms)
  2583. # else
  2584. (pIndex, pIndex_terms)
  2585. tTree pIndex;
  2586. tTree pIndex_terms;
  2587. # endif
  2588. {
  2589.  register tTree yyt;
  2590.  yyALLOC (yyt, Tree_NodeSize [kIndex_clause])
  2591.  yyt->Kind = kIndex_clause;
  2592.  yyt->yyHead.yyMark = 0;
  2593.  yyt->Index_clause.Index = pIndex;
  2594.  yyt->Index_clause.Index_terms = pIndex_terms;
  2595.  return yyt;
  2596. }
  2597.  
  2598. tTree mClass_header
  2599. # if defined __STDC__ | defined __cplusplus
  2600. ()
  2601. # else
  2602. ()
  2603. # endif
  2604. {
  2605.  register tTree yyt;
  2606.  yyALLOC (yyt, Tree_NodeSize [kClass_header])
  2607.  yyt->Kind = kClass_header;
  2608.  yyt->yyHead.yyMark = 0;
  2609.  return yyt;
  2610. }
  2611.  
  2612. tTree mClass_header0
  2613. # if defined __STDC__ | defined __cplusplus
  2614. ()
  2615. # else
  2616. ()
  2617. # endif
  2618. {
  2619.  register tTree yyt;
  2620.  yyALLOC (yyt, Tree_NodeSize [kClass_header0])
  2621.  yyt->Kind = kClass_header0;
  2622.  yyt->yyHead.yyMark = 0;
  2623.  return yyt;
  2624. }
  2625.  
  2626. tTree mClass
  2627. # if defined __STDC__ | defined __cplusplus
  2628. (tTree pName)
  2629. # else
  2630. (pName)
  2631. tTree pName;
  2632. # endif
  2633. {
  2634.  register tTree yyt;
  2635.  yyALLOC (yyt, Tree_NodeSize [kClass])
  2636.  yyt->Kind = kClass;
  2637.  yyt->yyHead.yyMark = 0;
  2638.  yyt->Class.Name = pName;
  2639.  return yyt;
  2640. }
  2641.  
  2642. tTree mExpanded_class
  2643. # if defined __STDC__ | defined __cplusplus
  2644. (tTree pName)
  2645. # else
  2646. (pName)
  2647. tTree pName;
  2648. # endif
  2649. {
  2650.  register tTree yyt;
  2651.  yyALLOC (yyt, Tree_NodeSize [kExpanded_class])
  2652.  yyt->Kind = kExpanded_class;
  2653.  yyt->yyHead.yyMark = 0;
  2654.  yyt->Expanded_class.Name = pName;
  2655.  return yyt;
  2656. }
  2657.  
  2658. tTree mDeferred_class
  2659. # if defined __STDC__ | defined __cplusplus
  2660. (tTree pName)
  2661. # else
  2662. (pName)
  2663. tTree pName;
  2664. # endif
  2665. {
  2666.  register tTree yyt;
  2667.  yyALLOC (yyt, Tree_NodeSize [kDeferred_class])
  2668.  yyt->Kind = kDeferred_class;
  2669.  yyt->yyHead.yyMark = 0;
  2670.  yyt->Deferred_class.Name = pName;
  2671.  return yyt;
  2672. }
  2673.  
  2674. tTree mFeatures
  2675. # if defined __STDC__ | defined __cplusplus
  2676. ()
  2677. # else
  2678. ()
  2679. # endif
  2680. {
  2681.  register tTree yyt;
  2682.  yyALLOC (yyt, Tree_NodeSize [kFeatures])
  2683.  yyt->Kind = kFeatures;
  2684.  yyt->yyHead.yyMark = 0;
  2685.  return yyt;
  2686. }
  2687.  
  2688. tTree mFeatures0
  2689. # if defined __STDC__ | defined __cplusplus
  2690. ()
  2691. # else
  2692. ()
  2693. # endif
  2694. {
  2695.  register tTree yyt;
  2696.  yyALLOC (yyt, Tree_NodeSize [kFeatures0])
  2697.  yyt->Kind = kFeatures0;
  2698.  yyt->yyHead.yyMark = 0;
  2699.  return yyt;
  2700. }
  2701.  
  2702. tTree mFeatures1
  2703. # if defined __STDC__ | defined __cplusplus
  2704. (tTree pFeature_clause, tTree pFeatures)
  2705. # else
  2706. (pFeature_clause, pFeatures)
  2707. tTree pFeature_clause;
  2708. tTree pFeatures;
  2709. # endif
  2710. {
  2711.  register tTree yyt;
  2712.  yyALLOC (yyt, Tree_NodeSize [kFeatures1])
  2713.  yyt->Kind = kFeatures1;
  2714.  yyt->yyHead.yyMark = 0;
  2715.  yyt->Features1.Feature_clause = pFeature_clause;
  2716.  yyt->Features1.Features = pFeatures;
  2717.  return yyt;
  2718. }
  2719.  
  2720. tTree mFeature_clause
  2721. # if defined __STDC__ | defined __cplusplus
  2722. (tTree pClients, tStringRef pcomment, tTree pFeature_decls)
  2723. # else
  2724. (pClients, pcomment, pFeature_decls)
  2725. tTree pClients;
  2726. tStringRef pcomment;
  2727. tTree pFeature_decls;
  2728. # endif
  2729. {
  2730.  register tTree yyt;
  2731.  yyALLOC (yyt, Tree_NodeSize [kFeature_clause])
  2732.  yyt->Kind = kFeature_clause;
  2733.  yyt->yyHead.yyMark = 0;
  2734.  yyt->Feature_clause.Clients = pClients;
  2735.  yyt->Feature_clause.comment = pcomment;
  2736.  yyt->Feature_clause.Feature_decls = pFeature_decls;
  2737.  return yyt;
  2738. }
  2739.  
  2740. tTree mClients
  2741. # if defined __STDC__ | defined __cplusplus
  2742. ()
  2743. # else
  2744. ()
  2745. # endif
  2746. {
  2747.  register tTree yyt;
  2748.  yyALLOC (yyt, Tree_NodeSize [kClients])
  2749.  yyt->Kind = kClients;
  2750.  yyt->yyHead.yyMark = 0;
  2751.  return yyt;
  2752. }
  2753.  
  2754. tTree mClients0
  2755. # if defined __STDC__ | defined __cplusplus
  2756. ()
  2757. # else
  2758. ()
  2759. # endif
  2760. {
  2761.  register tTree yyt;
  2762.  yyALLOC (yyt, Tree_NodeSize [kClients0])
  2763.  yyt->Kind = kClients0;
  2764.  yyt->yyHead.yyMark = 0;
  2765.  return yyt;
  2766. }
  2767.  
  2768. tTree mClients1
  2769. # if defined __STDC__ | defined __cplusplus
  2770. (tTree pList)
  2771. # else
  2772. (pList)
  2773. tTree pList;
  2774. # endif
  2775. {
  2776.  register tTree yyt;
  2777.  yyALLOC (yyt, Tree_NodeSize [kClients1])
  2778.  yyt->Kind = kClients1;
  2779.  yyt->yyHead.yyMark = 0;
  2780.  yyt->Clients1.List = pList;
  2781.  return yyt;
  2782. }
  2783.  
  2784. tTree mFeature_decls
  2785. # if defined __STDC__ | defined __cplusplus
  2786. ()
  2787. # else
  2788. ()
  2789. # endif
  2790. {
  2791.  register tTree yyt;
  2792.  yyALLOC (yyt, Tree_NodeSize [kFeature_decls])
  2793.  yyt->Kind = kFeature_decls;
  2794.  yyt->yyHead.yyMark = 0;
  2795.  return yyt;
  2796. }
  2797.  
  2798. tTree mFeature_decls0
  2799. # if defined __STDC__ | defined __cplusplus
  2800. ()
  2801. # else
  2802. ()
  2803. # endif
  2804. {
  2805.  register tTree yyt;
  2806.  yyALLOC (yyt, Tree_NodeSize [kFeature_decls0])
  2807.  yyt->Kind = kFeature_decls0;
  2808.  yyt->yyHead.yyMark = 0;
  2809.  return yyt;
  2810. }
  2811.  
  2812. tTree mFeature_decls1
  2813. # if defined __STDC__ | defined __cplusplus
  2814. (tTree pFeature_decl, tTree pFeature_decls)
  2815. # else
  2816. (pFeature_decl, pFeature_decls)
  2817. tTree pFeature_decl;
  2818. tTree pFeature_decls;
  2819. # endif
  2820. {
  2821.  register tTree yyt;
  2822.  yyALLOC (yyt, Tree_NodeSize [kFeature_decls1])
  2823.  yyt->Kind = kFeature_decls1;
  2824.  yyt->yyHead.yyMark = 0;
  2825.  yyt->Feature_decls1.Feature_decl = pFeature_decl;
  2826.  yyt->Feature_decls1.Feature_decls = pFeature_decls;
  2827.  return yyt;
  2828. }
  2829.  
  2830. tTree mFeature_decl
  2831. # if defined __STDC__ | defined __cplusplus
  2832. (tTree pNew_feature_list, tTree pDeclaration_body)
  2833. # else
  2834. (pNew_feature_list, pDeclaration_body)
  2835. tTree pNew_feature_list;
  2836. tTree pDeclaration_body;
  2837. # endif
  2838. {
  2839.  register tTree yyt;
  2840.  yyALLOC (yyt, Tree_NodeSize [kFeature_decl])
  2841.  yyt->Kind = kFeature_decl;
  2842.  yyt->yyHead.yyMark = 0;
  2843.  yyt->Feature_decl.New_feature_list = pNew_feature_list;
  2844.  yyt->Feature_decl.Declaration_body = pDeclaration_body;
  2845.  return yyt;
  2846. }
  2847.  
  2848. tTree mDeclaration_body
  2849. # if defined __STDC__ | defined __cplusplus
  2850. (tTree pFormal_args, tTree pType_mark, tTree pConst_or_routine)
  2851. # else
  2852. (pFormal_args, pType_mark, pConst_or_routine)
  2853. tTree pFormal_args;
  2854. tTree pType_mark;
  2855. tTree pConst_or_routine;
  2856. # endif
  2857. {
  2858.  register tTree yyt;
  2859.  yyALLOC (yyt, Tree_NodeSize [kDeclaration_body])
  2860.  yyt->Kind = kDeclaration_body;
  2861.  yyt->yyHead.yyMark = 0;
  2862.  yyt->Declaration_body.Formal_args = pFormal_args;
  2863.  yyt->Declaration_body.Type_mark = pType_mark;
  2864.  yyt->Declaration_body.Const_or_routine = pConst_or_routine;
  2865.  return yyt;
  2866. }
  2867.  
  2868. tTree mConst_or_routine
  2869. # if defined __STDC__ | defined __cplusplus
  2870. ()
  2871. # else
  2872. ()
  2873. # endif
  2874. {
  2875.  register tTree yyt;
  2876.  yyALLOC (yyt, Tree_NodeSize [kConst_or_routine])
  2877.  yyt->Kind = kConst_or_routine;
  2878.  yyt->yyHead.yyMark = 0;
  2879.  return yyt;
  2880. }
  2881.  
  2882. tTree mConst_or_routine0
  2883. # if defined __STDC__ | defined __cplusplus
  2884. ()
  2885. # else
  2886. ()
  2887. # endif
  2888. {
  2889.  register tTree yyt;
  2890.  yyALLOC (yyt, Tree_NodeSize [kConst_or_routine0])
  2891.  yyt->Kind = kConst_or_routine0;
  2892.  yyt->yyHead.yyMark = 0;
  2893.  return yyt;
  2894. }
  2895.  
  2896. tTree mM_const
  2897. # if defined __STDC__ | defined __cplusplus
  2898. (tTree pManifest_constant)
  2899. # else
  2900. (pManifest_constant)
  2901. tTree pManifest_constant;
  2902. # endif
  2903. {
  2904.  register tTree yyt;
  2905.  yyALLOC (yyt, Tree_NodeSize [kM_const])
  2906.  yyt->Kind = kM_const;
  2907.  yyt->yyHead.yyMark = 0;
  2908.  yyt->M_const.Manifest_constant = pManifest_constant;
  2909.  return yyt;
  2910. }
  2911.  
  2912. tTree mUnique
  2913. # if defined __STDC__ | defined __cplusplus
  2914. (tPosition ppos)
  2915. # else
  2916. (ppos)
  2917. tPosition ppos;
  2918. # endif
  2919. {
  2920.  register tTree yyt;
  2921.  yyALLOC (yyt, Tree_NodeSize [kUnique])
  2922.  yyt->Kind = kUnique;
  2923.  yyt->yyHead.yyMark = 0;
  2924.  yyt->Unique.pos = ppos;
  2925.  return yyt;
  2926. }
  2927.  
  2928. tTree mRoutine
  2929. # if defined __STDC__ | defined __cplusplus
  2930. (tTree pObsolete, tStringRef pcomment, tTree pPrecondition, tTree pLocal_decls, tTree pRoutine_body, tTree pPostcondition, tTree pRescue, tStringRef pend_comment)
  2931. # else
  2932. (pObsolete, pcomment, pPrecondition, pLocal_decls, pRoutine_body, pPostcondition, pRescue, pend_comment)
  2933. tTree pObsolete;
  2934. tStringRef pcomment;
  2935. tTree pPrecondition;
  2936. tTree pLocal_decls;
  2937. tTree pRoutine_body;
  2938. tTree pPostcondition;
  2939. tTree pRescue;
  2940. tStringRef pend_comment;
  2941. # endif
  2942. {
  2943.  register tTree yyt;
  2944.  yyALLOC (yyt, Tree_NodeSize [kRoutine])
  2945.  yyt->Kind = kRoutine;
  2946.  yyt->yyHead.yyMark = 0;
  2947.  yyt->Routine.Obsolete = pObsolete;
  2948.  yyt->Routine.comment = pcomment;
  2949.  yyt->Routine.Precondition = pPrecondition;
  2950.  yyt->Routine.Local_decls = pLocal_decls;
  2951.  yyt->Routine.Routine_body = pRoutine_body;
  2952.  yyt->Routine.Postcondition = pPostcondition;
  2953.  yyt->Routine.Rescue = pRescue;
  2954.  yyt->Routine.end_comment = pend_comment;
  2955.  return yyt;
  2956. }
  2957.  
  2958. tTree mParent_list
  2959. # if defined __STDC__ | defined __cplusplus
  2960. ()
  2961. # else
  2962. ()
  2963. # endif
  2964. {
  2965.  register tTree yyt;
  2966.  yyALLOC (yyt, Tree_NodeSize [kParent_list])
  2967.  yyt->Kind = kParent_list;
  2968.  yyt->yyHead.yyMark = 0;
  2969.  return yyt;
  2970. }
  2971.  
  2972. tTree mParent_list0
  2973. # if defined __STDC__ | defined __cplusplus
  2974. ()
  2975. # else
  2976. ()
  2977. # endif
  2978. {
  2979.  register tTree yyt;
  2980.  yyALLOC (yyt, Tree_NodeSize [kParent_list0])
  2981.  yyt->Kind = kParent_list0;
  2982.  yyt->yyHead.yyMark = 0;
  2983.  return yyt;
  2984. }
  2985.  
  2986. tTree mParent_list1
  2987. # if defined __STDC__ | defined __cplusplus
  2988. (tTree pParent, tTree pParent_list)
  2989. # else
  2990. (pParent, pParent_list)
  2991. tTree pParent;
  2992. tTree pParent_list;
  2993. # endif
  2994. {
  2995.  register tTree yyt;
  2996.  yyALLOC (yyt, Tree_NodeSize [kParent_list1])
  2997.  yyt->Kind = kParent_list1;
  2998.  yyt->yyHead.yyMark = 0;
  2999.  yyt->Parent_list1.Parent = pParent;
  3000.  yyt->Parent_list1.Parent_list = pParent_list;
  3001.  return yyt;
  3002. }
  3003.  
  3004. tTree mParent
  3005. # if defined __STDC__ | defined __cplusplus
  3006. (tTree pClass_type, tTree pFeature_adaptation)
  3007. # else
  3008. (pClass_type, pFeature_adaptation)
  3009. tTree pClass_type;
  3010. tTree pFeature_adaptation;
  3011. # endif
  3012. {
  3013.  register tTree yyt;
  3014.  yyALLOC (yyt, Tree_NodeSize [kParent])
  3015.  yyt->Kind = kParent;
  3016.  yyt->yyHead.yyMark = 0;
  3017.  yyt->Parent.Class_type = pClass_type;
  3018.  yyt->Parent.Feature_adaptation = pFeature_adaptation;
  3019.  return yyt;
  3020. }
  3021.  
  3022. tTree mFeature_adaptation
  3023. # if defined __STDC__ | defined __cplusplus
  3024. ()
  3025. # else
  3026. ()
  3027. # endif
  3028. {
  3029.  register tTree yyt;
  3030.  yyALLOC (yyt, Tree_NodeSize [kFeature_adaptation])
  3031.  yyt->Kind = kFeature_adaptation;
  3032.  yyt->yyHead.yyMark = 0;
  3033.  return yyt;
  3034. }
  3035.  
  3036. tTree mFeature_adaptation0
  3037. # if defined __STDC__ | defined __cplusplus
  3038. ()
  3039. # else
  3040. ()
  3041. # endif
  3042. {
  3043.  register tTree yyt;
  3044.  yyALLOC (yyt, Tree_NodeSize [kFeature_adaptation0])
  3045.  yyt->Kind = kFeature_adaptation0;
  3046.  yyt->yyHead.yyMark = 0;
  3047.  return yyt;
  3048. }
  3049.  
  3050. tTree mFeature_adaptation1
  3051. # if defined __STDC__ | defined __cplusplus
  3052. (tTree pRename, tTree pNew_export, tTree pUndefine, tTree pRedefine, tTree pSelect)
  3053. # else
  3054. (pRename, pNew_export, pUndefine, pRedefine, pSelect)
  3055. tTree pRename;
  3056. tTree pNew_export;
  3057. tTree pUndefine;
  3058. tTree pRedefine;
  3059. tTree pSelect;
  3060. # endif
  3061. {
  3062.  register tTree yyt;
  3063.  yyALLOC (yyt, Tree_NodeSize [kFeature_adaptation1])
  3064.  yyt->Kind = kFeature_adaptation1;
  3065.  yyt->yyHead.yyMark = 0;
  3066.  yyt->Feature_adaptation1.Rename = pRename;
  3067.  yyt->Feature_adaptation1.New_export = pNew_export;
  3068.  yyt->Feature_adaptation1.Undefine = pUndefine;
  3069.  yyt->Feature_adaptation1.Redefine = pRedefine;
  3070.  yyt->Feature_adaptation1.Select = pSelect;
  3071.  return yyt;
  3072. }
  3073.  
  3074. tTree mRename_list
  3075. # if defined __STDC__ | defined __cplusplus
  3076. ()
  3077. # else
  3078. ()
  3079. # endif
  3080. {
  3081.  register tTree yyt;
  3082.  yyALLOC (yyt, Tree_NodeSize [kRename_list])
  3083.  yyt->Kind = kRename_list;
  3084.  yyt->yyHead.yyMark = 0;
  3085.  return yyt;
  3086. }
  3087.  
  3088. tTree mRename_list0
  3089. # if defined __STDC__ | defined __cplusplus
  3090. ()
  3091. # else
  3092. ()
  3093. # endif
  3094. {
  3095.  register tTree yyt;
  3096.  yyALLOC (yyt, Tree_NodeSize [kRename_list0])
  3097.  yyt->Kind = kRename_list0;
  3098.  yyt->yyHead.yyMark = 0;
  3099.  return yyt;
  3100. }
  3101.  
  3102. tTree mRename_list1
  3103. # if defined __STDC__ | defined __cplusplus
  3104. (tTree pRename_pair, tTree pRename_list)
  3105. # else
  3106. (pRename_pair, pRename_list)
  3107. tTree pRename_pair;
  3108. tTree pRename_list;
  3109. # endif
  3110. {
  3111.  register tTree yyt;
  3112.  yyALLOC (yyt, Tree_NodeSize [kRename_list1])
  3113.  yyt->Kind = kRename_list1;
  3114.  yyt->yyHead.yyMark = 0;
  3115.  yyt->Rename_list1.Rename_pair = pRename_pair;
  3116.  yyt->Rename_list1.Rename_list = pRename_list;
  3117.  return yyt;
  3118. }
  3119.  
  3120. tTree mRename_pair
  3121. # if defined __STDC__ | defined __cplusplus
  3122. (tTree pName1, tTree pName2)
  3123. # else
  3124. (pName1, pName2)
  3125. tTree pName1;
  3126. tTree pName2;
  3127. # endif
  3128. {
  3129.  register tTree yyt;
  3130.  yyALLOC (yyt, Tree_NodeSize [kRename_pair])
  3131.  yyt->Kind = kRename_pair;
  3132.  yyt->yyHead.yyMark = 0;
  3133.  yyt->Rename_pair.Name1 = pName1;
  3134.  yyt->Rename_pair.Name2 = pName2;
  3135.  return yyt;
  3136. }
  3137.  
  3138. tTree mCreators
  3139. # if defined __STDC__ | defined __cplusplus
  3140. ()
  3141. # else
  3142. ()
  3143. # endif
  3144. {
  3145.  register tTree yyt;
  3146.  yyALLOC (yyt, Tree_NodeSize [kCreators])
  3147.  yyt->Kind = kCreators;
  3148.  yyt->yyHead.yyMark = 0;
  3149.  return yyt;
  3150. }
  3151.  
  3152. tTree mCreators0
  3153. # if defined __STDC__ | defined __cplusplus
  3154. ()
  3155. # else
  3156. ()
  3157. # endif
  3158. {
  3159.  register tTree yyt;
  3160.  yyALLOC (yyt, Tree_NodeSize [kCreators0])
  3161.  yyt->Kind = kCreators0;
  3162.  yyt->yyHead.yyMark = 0;
  3163.  return yyt;
  3164. }
  3165.  
  3166. tTree mCreators1
  3167. # if defined __STDC__ | defined __cplusplus
  3168. (tTree pCreation_clause, tTree pCreators)
  3169. # else
  3170. (pCreation_clause, pCreators)
  3171. tTree pCreation_clause;
  3172. tTree pCreators;
  3173. # endif
  3174. {
  3175.  register tTree yyt;
  3176.  yyALLOC (yyt, Tree_NodeSize [kCreators1])
  3177.  yyt->Kind = kCreators1;
  3178.  yyt->yyHead.yyMark = 0;
  3179.  yyt->Creators1.Creation_clause = pCreation_clause;
  3180.  yyt->Creators1.Creators = pCreators;
  3181.  return yyt;
  3182. }
  3183.  
  3184. tTree mCreation_clause
  3185. # if defined __STDC__ | defined __cplusplus
  3186. (tTree pClients, tStringRef pcomment, tTree pFeature_list)
  3187. # else
  3188. (pClients, pcomment, pFeature_list)
  3189. tTree pClients;
  3190. tStringRef pcomment;
  3191. tTree pFeature_list;
  3192. # endif
  3193. {
  3194.  register tTree yyt;
  3195.  yyALLOC (yyt, Tree_NodeSize [kCreation_clause])
  3196.  yyt->Kind = kCreation_clause;
  3197.  yyt->yyHead.yyMark = 0;
  3198.  yyt->Creation_clause.Clients = pClients;
  3199.  yyt->Creation_clause.comment = pcomment;
  3200.  yyt->Creation_clause.Feature_list = pFeature_list;
  3201.  return yyt;
  3202. }
  3203.  
  3204. tTree mNew_feature_list
  3205. # if defined __STDC__ | defined __cplusplus
  3206. ()
  3207. # else
  3208. ()
  3209. # endif
  3210. {
  3211.  register tTree yyt;
  3212.  yyALLOC (yyt, Tree_NodeSize [kNew_feature_list])
  3213.  yyt->Kind = kNew_feature_list;
  3214.  yyt->yyHead.yyMark = 0;
  3215.  return yyt;
  3216. }
  3217.  
  3218. tTree mNew_feature_list0
  3219. # if defined __STDC__ | defined __cplusplus
  3220. ()
  3221. # else
  3222. ()
  3223. # endif
  3224. {
  3225.  register tTree yyt;
  3226.  yyALLOC (yyt, Tree_NodeSize [kNew_feature_list0])
  3227.  yyt->Kind = kNew_feature_list0;
  3228.  yyt->yyHead.yyMark = 0;
  3229.  return yyt;
  3230. }
  3231.  
  3232. tTree mNew_feature_list1
  3233. # if defined __STDC__ | defined __cplusplus
  3234. (tTree pFeature_name, tTree pNew_feature_list)
  3235. # else
  3236. (pFeature_name, pNew_feature_list)
  3237. tTree pFeature_name;
  3238. tTree pNew_feature_list;
  3239. # endif
  3240. {
  3241.  register tTree yyt;
  3242.  yyALLOC (yyt, Tree_NodeSize [kNew_feature_list1])
  3243.  yyt->Kind = kNew_feature_list1;
  3244.  yyt->yyHead.yyMark = 0;
  3245.  yyt->New_feature_list1.Feature_name = pFeature_name;
  3246.  yyt->New_feature_list1.New_feature_list = pNew_feature_list;
  3247.  return yyt;
  3248. }
  3249.  
  3250. tTree mFeature_name
  3251. # if defined __STDC__ | defined __cplusplus
  3252. ()
  3253. # else
  3254. ()
  3255. # endif
  3256. {
  3257.  register tTree yyt;
  3258.  yyALLOC (yyt, Tree_NodeSize [kFeature_name])
  3259.  yyt->Kind = kFeature_name;
  3260.  yyt->yyHead.yyMark = 0;
  3261.  return yyt;
  3262. }
  3263.  
  3264. tTree mFrozen
  3265. # if defined __STDC__ | defined __cplusplus
  3266. (tTree pFeature_name)
  3267. # else
  3268. (pFeature_name)
  3269. tTree pFeature_name;
  3270. # endif
  3271. {
  3272.  register tTree yyt;
  3273.  yyALLOC (yyt, Tree_NodeSize [kFrozen])
  3274.  yyt->Kind = kFrozen;
  3275.  yyt->yyHead.yyMark = 0;
  3276.  yyt->Frozen.Feature_name = pFeature_name;
  3277.  return yyt;
  3278. }
  3279.  
  3280. tTree mIdent_name
  3281. # if defined __STDC__ | defined __cplusplus
  3282. (tTree pId)
  3283. # else
  3284. (pId)
  3285. tTree pId;
  3286. # endif
  3287. {
  3288.  register tTree yyt;
  3289.  yyALLOC (yyt, Tree_NodeSize [kIdent_name])
  3290.  yyt->Kind = kIdent_name;
  3291.  yyt->yyHead.yyMark = 0;
  3292.  yyt->Ident_name.Id = pId;
  3293.  return yyt;
  3294. }
  3295.  
  3296. tTree mOp
  3297. # if defined __STDC__ | defined __cplusplus
  3298. ()
  3299. # else
  3300. ()
  3301. # endif
  3302. {
  3303.  register tTree yyt;
  3304.  yyALLOC (yyt, Tree_NodeSize [kOp])
  3305.  yyt->Kind = kOp;
  3306.  yyt->yyHead.yyMark = 0;
  3307.  return yyt;
  3308. }
  3309.  
  3310. tTree mPrefix
  3311. # if defined __STDC__ | defined __cplusplus
  3312. (tTree pOp_name)
  3313. # else
  3314. (pOp_name)
  3315. tTree pOp_name;
  3316. # endif
  3317. {
  3318.  register tTree yyt;
  3319.  yyALLOC (yyt, Tree_NodeSize [kPrefix])
  3320.  yyt->Kind = kPrefix;
  3321.  yyt->yyHead.yyMark = 0;
  3322.  yyt->Prefix.Op_name = pOp_name;
  3323.  return yyt;
  3324. }
  3325.  
  3326. tTree mInfix
  3327. # if defined __STDC__ | defined __cplusplus
  3328. (tTree pOp_name)
  3329. # else
  3330. (pOp_name)
  3331. tTree pOp_name;
  3332. # endif
  3333. {
  3334.  register tTree yyt;
  3335.  yyALLOC (yyt, Tree_NodeSize [kInfix])
  3336.  yyt->Kind = kInfix;
  3337.  yyt->yyHead.yyMark = 0;
  3338.  yyt->Infix.Op_name = pOp_name;
  3339.  return yyt;
  3340. }
  3341.  
  3342. tTree mOp_name
  3343. # if defined __STDC__ | defined __cplusplus
  3344. (tPosition ppos)
  3345. # else
  3346. (ppos)
  3347. tPosition ppos;
  3348. # endif
  3349. {
  3350.  register tTree yyt;
  3351.  yyALLOC (yyt, Tree_NodeSize [kOp_name])
  3352.  yyt->Kind = kOp_name;
  3353.  yyt->yyHead.yyMark = 0;
  3354.  yyt->Op_name.pos = ppos;
  3355.  return yyt;
  3356. }
  3357.  
  3358. tTree mFree_op
  3359. # if defined __STDC__ | defined __cplusplus
  3360. (tPosition ppos, tIdent pident)
  3361. # else
  3362. (ppos, pident)
  3363. tPosition ppos;
  3364. tIdent pident;
  3365. # endif
  3366. {
  3367.  register tTree yyt;
  3368.  yyALLOC (yyt, Tree_NodeSize [kFree_op])
  3369.  yyt->Kind = kFree_op;
  3370.  yyt->yyHead.yyMark = 0;
  3371.  yyt->Free_op.pos = ppos;
  3372.  yyt->Free_op.ident = pident;
  3373.  return yyt;
  3374. }
  3375.  
  3376. tTree mOper
  3377. # if defined __STDC__ | defined __cplusplus
  3378. (tPosition ppos, int pop)
  3379. # else
  3380. (ppos, pop)
  3381. tPosition ppos;
  3382. int pop;
  3383. # endif
  3384. {
  3385.  register tTree yyt;
  3386.  yyALLOC (yyt, Tree_NodeSize [kOper])
  3387.  yyt->Kind = kOper;
  3388.  yyt->yyHead.yyMark = 0;
  3389.  yyt->Oper.pos = ppos;
  3390.  yyt->Oper.op = pop;
  3391.  return yyt;
  3392. }
  3393.  
  3394. tTree mNew_export_list
  3395. # if defined __STDC__ | defined __cplusplus
  3396. ()
  3397. # else
  3398. ()
  3399. # endif
  3400. {
  3401.  register tTree yyt;
  3402.  yyALLOC (yyt, Tree_NodeSize [kNew_export_list])
  3403.  yyt->Kind = kNew_export_list;
  3404.  yyt->yyHead.yyMark = 0;
  3405.  return yyt;
  3406. }
  3407.  
  3408. tTree mNew_export_list0
  3409. # if defined __STDC__ | defined __cplusplus
  3410. ()
  3411. # else
  3412. ()
  3413. # endif
  3414. {
  3415.  register tTree yyt;
  3416.  yyALLOC (yyt, Tree_NodeSize [kNew_export_list0])
  3417.  yyt->Kind = kNew_export_list0;
  3418.  yyt->yyHead.yyMark = 0;
  3419.  return yyt;
  3420. }
  3421.  
  3422. tTree mNew_export_list1
  3423. # if defined __STDC__ | defined __cplusplus
  3424. (tTree pNew_export_item, tTree pNew_export_list)
  3425. # else
  3426. (pNew_export_item, pNew_export_list)
  3427. tTree pNew_export_item;
  3428. tTree pNew_export_list;
  3429. # endif
  3430. {
  3431.  register tTree yyt;
  3432.  yyALLOC (yyt, Tree_NodeSize [kNew_export_list1])
  3433.  yyt->Kind = kNew_export_list1;
  3434.  yyt->yyHead.yyMark = 0;
  3435.  yyt->New_export_list1.New_export_item = pNew_export_item;
  3436.  yyt->New_export_list1.New_export_list = pNew_export_list;
  3437.  return yyt;
  3438. }
  3439.  
  3440. tTree mNew_export_item
  3441. # if defined __STDC__ | defined __cplusplus
  3442. (tTree pClients, tTree pFeature_set)
  3443. # else
  3444. (pClients, pFeature_set)
  3445. tTree pClients;
  3446. tTree pFeature_set;
  3447. # endif
  3448. {
  3449.  register tTree yyt;
  3450.  yyALLOC (yyt, Tree_NodeSize [kNew_export_item])
  3451.  yyt->Kind = kNew_export_item;
  3452.  yyt->yyHead.yyMark = 0;
  3453.  yyt->New_export_item.Clients = pClients;
  3454.  yyt->New_export_item.Feature_set = pFeature_set;
  3455.  return yyt;
  3456. }
  3457.  
  3458. tTree mFeature_list
  3459. # if defined __STDC__ | defined __cplusplus
  3460. ()
  3461. # else
  3462. ()
  3463. # endif
  3464. {
  3465.  register tTree yyt;
  3466.  yyALLOC (yyt, Tree_NodeSize [kFeature_list])
  3467.  yyt->Kind = kFeature_list;
  3468.  yyt->yyHead.yyMark = 0;
  3469.  return yyt;
  3470. }
  3471.  
  3472. tTree mAll
  3473. # if defined __STDC__ | defined __cplusplus
  3474. ()
  3475. # else
  3476. ()
  3477. # endif
  3478. {
  3479.  register tTree yyt;
  3480.  yyALLOC (yyt, Tree_NodeSize [kAll])
  3481.  yyt->Kind = kAll;
  3482.  yyt->yyHead.yyMark = 0;
  3483.  return yyt;
  3484. }
  3485.  
  3486. tTree mFeature_list0
  3487. # if defined __STDC__ | defined __cplusplus
  3488. ()
  3489. # else
  3490. ()
  3491. # endif
  3492. {
  3493.  register tTree yyt;
  3494.  yyALLOC (yyt, Tree_NodeSize [kFeature_list0])
  3495.  yyt->Kind = kFeature_list0;
  3496.  yyt->yyHead.yyMark = 0;
  3497.  return yyt;
  3498. }
  3499.  
  3500. tTree mFeature_list1
  3501. # if defined __STDC__ | defined __cplusplus
  3502. (tTree pFeature_name, tTree pFeature_list)
  3503. # else
  3504. (pFeature_name, pFeature_list)
  3505. tTree pFeature_name;
  3506. tTree pFeature_list;
  3507. # endif
  3508. {
  3509.  register tTree yyt;
  3510.  yyALLOC (yyt, Tree_NodeSize [kFeature_list1])
  3511.  yyt->Kind = kFeature_list1;
  3512.  yyt->yyHead.yyMark = 0;
  3513.  yyt->Feature_list1.Feature_name = pFeature_name;
  3514.  yyt->Feature_list1.Feature_list = pFeature_list;
  3515.  return yyt;
  3516. }
  3517.  
  3518. tTree mFormal_args
  3519. # if defined __STDC__ | defined __cplusplus
  3520. ()
  3521. # else
  3522. ()
  3523. # endif
  3524. {
  3525.  register tTree yyt;
  3526.  yyALLOC (yyt, Tree_NodeSize [kFormal_args])
  3527.  yyt->Kind = kFormal_args;
  3528.  yyt->yyHead.yyMark = 0;
  3529.  return yyt;
  3530. }
  3531.  
  3532. tTree mFormal_args0
  3533. # if defined __STDC__ | defined __cplusplus
  3534. ()
  3535. # else
  3536. ()
  3537. # endif
  3538. {
  3539.  register tTree yyt;
  3540.  yyALLOC (yyt, Tree_NodeSize [kFormal_args0])
  3541.  yyt->Kind = kFormal_args0;
  3542.  yyt->yyHead.yyMark = 0;
  3543.  return yyt;
  3544. }
  3545.  
  3546. tTree mFormal_args1
  3547. # if defined __STDC__ | defined __cplusplus
  3548. (tTree pEntity_decl_group, tTree pFormal_args)
  3549. # else
  3550. (pEntity_decl_group, pFormal_args)
  3551. tTree pEntity_decl_group;
  3552. tTree pFormal_args;
  3553. # endif
  3554. {
  3555.  register tTree yyt;
  3556.  yyALLOC (yyt, Tree_NodeSize [kFormal_args1])
  3557.  yyt->Kind = kFormal_args1;
  3558.  yyt->yyHead.yyMark = 0;
  3559.  yyt->Formal_args1.Entity_decl_group = pEntity_decl_group;
  3560.  yyt->Formal_args1.Formal_args = pFormal_args;
  3561.  return yyt;
  3562. }
  3563.  
  3564. tTree mRoutine_body
  3565. # if defined __STDC__ | defined __cplusplus
  3566. ()
  3567. # else
  3568. ()
  3569. # endif
  3570. {
  3571.  register tTree yyt;
  3572.  yyALLOC (yyt, Tree_NodeSize [kRoutine_body])
  3573.  yyt->Kind = kRoutine_body;
  3574.  yyt->yyHead.yyMark = 0;
  3575.  return yyt;
  3576. }
  3577.  
  3578. tTree mRoutine_body0
  3579. # if defined __STDC__ | defined __cplusplus
  3580. ()
  3581. # else
  3582. ()
  3583. # endif
  3584. {
  3585.  register tTree yyt;
  3586.  yyALLOC (yyt, Tree_NodeSize [kRoutine_body0])
  3587.  yyt->Kind = kRoutine_body0;
  3588.  yyt->yyHead.yyMark = 0;
  3589.  return yyt;
  3590. }
  3591.  
  3592. tTree mEffective
  3593. # if defined __STDC__ | defined __cplusplus
  3594. ()
  3595. # else
  3596. ()
  3597. # endif
  3598. {
  3599.  register tTree yyt;
  3600.  yyALLOC (yyt, Tree_NodeSize [kEffective])
  3601.  yyt->Kind = kEffective;
  3602.  yyt->yyHead.yyMark = 0;
  3603.  return yyt;
  3604. }
  3605.  
  3606. tTree mInternal
  3607. # if defined __STDC__ | defined __cplusplus
  3608. ()
  3609. # else
  3610. ()
  3611. # endif
  3612. {
  3613.  register tTree yyt;
  3614.  yyALLOC (yyt, Tree_NodeSize [kInternal])
  3615.  yyt->Kind = kInternal;
  3616.  yyt->yyHead.yyMark = 0;
  3617.  return yyt;
  3618. }
  3619.  
  3620. tTree mDo_body
  3621. # if defined __STDC__ | defined __cplusplus
  3622. (tTree pCompound)
  3623. # else
  3624. (pCompound)
  3625. tTree pCompound;
  3626. # endif
  3627. {
  3628.  register tTree yyt;
  3629.  yyALLOC (yyt, Tree_NodeSize [kDo_body])
  3630.  yyt->Kind = kDo_body;
  3631.  yyt->yyHead.yyMark = 0;
  3632.  yyt->Do_body.Compound = pCompound;
  3633.  return yyt;
  3634. }
  3635.  
  3636. tTree mOnce_body
  3637. # if defined __STDC__ | defined __cplusplus
  3638. (tTree pCompound)
  3639. # else
  3640. (pCompound)
  3641. tTree pCompound;
  3642. # endif
  3643. {
  3644.  register tTree yyt;
  3645.  yyALLOC (yyt, Tree_NodeSize [kOnce_body])
  3646.  yyt->Kind = kOnce_body;
  3647.  yyt->yyHead.yyMark = 0;
  3648.  yyt->Once_body.Compound = pCompound;
  3649.  return yyt;
  3650. }
  3651.  
  3652. tTree mExternal
  3653. # if defined __STDC__ | defined __cplusplus
  3654. (tTree pLang1, tTree pLang2)
  3655. # else
  3656. (pLang1, pLang2)
  3657. tTree pLang1;
  3658. tTree pLang2;
  3659. # endif
  3660. {
  3661.  register tTree yyt;
  3662.  yyALLOC (yyt, Tree_NodeSize [kExternal])
  3663.  yyt->Kind = kExternal;
  3664.  yyt->yyHead.yyMark = 0;
  3665.  yyt->External.Lang1 = pLang1;
  3666.  yyt->External.Lang2 = pLang2;
  3667.  return yyt;
  3668. }
  3669.  
  3670. tTree mDeferred
  3671. # if defined __STDC__ | defined __cplusplus
  3672. (tPosition ppos)
  3673. # else
  3674. (ppos)
  3675. tPosition ppos;
  3676. # endif
  3677. {
  3678.  register tTree yyt;
  3679.  yyALLOC (yyt, Tree_NodeSize [kDeferred])
  3680.  yyt->Kind = kDeferred;
  3681.  yyt->yyHead.yyMark = 0;
  3682.  yyt->Deferred.pos = ppos;
  3683.  return yyt;
  3684. }
  3685.  
  3686. tTree mEntity_decl_group
  3687. # if defined __STDC__ | defined __cplusplus
  3688. (tTree pId_list, tTree pType_mark)
  3689. # else
  3690. (pId_list, pType_mark)
  3691. tTree pId_list;
  3692. tTree pType_mark;
  3693. # endif
  3694. {
  3695.  register tTree yyt;
  3696.  yyALLOC (yyt, Tree_NodeSize [kEntity_decl_group])
  3697.  yyt->Kind = kEntity_decl_group;
  3698.  yyt->yyHead.yyMark = 0;
  3699.  yyt->Entity_decl_group.Id_list = pId_list;
  3700.  yyt->Entity_decl_group.Type_mark = pType_mark;
  3701.  return yyt;
  3702. }
  3703.  
  3704. tTree mFormal_generics
  3705. # if defined __STDC__ | defined __cplusplus
  3706. ()
  3707. # else
  3708. ()
  3709. # endif
  3710. {
  3711.  register tTree yyt;
  3712.  yyALLOC (yyt, Tree_NodeSize [kFormal_generics])
  3713.  yyt->Kind = kFormal_generics;
  3714.  yyt->yyHead.yyMark = 0;
  3715.  return yyt;
  3716. }
  3717.  
  3718. tTree mFormal_generics0
  3719. # if defined __STDC__ | defined __cplusplus
  3720. ()
  3721. # else
  3722. ()
  3723. # endif
  3724. {
  3725.  register tTree yyt;
  3726.  yyALLOC (yyt, Tree_NodeSize [kFormal_generics0])
  3727.  yyt->Kind = kFormal_generics0;
  3728.  yyt->yyHead.yyMark = 0;
  3729.  return yyt;
  3730. }
  3731.  
  3732. tTree mFormal_generics1
  3733. # if defined __STDC__ | defined __cplusplus
  3734. (tTree pFormal_generic, tTree pFormal_generics)
  3735. # else
  3736. (pFormal_generic, pFormal_generics)
  3737. tTree pFormal_generic;
  3738. tTree pFormal_generics;
  3739. # endif
  3740. {
  3741.  register tTree yyt;
  3742.  yyALLOC (yyt, Tree_NodeSize [kFormal_generics1])
  3743.  yyt->Kind = kFormal_generics1;
  3744.  yyt->yyHead.yyMark = 0;
  3745.  yyt->Formal_generics1.Formal_generic = pFormal_generic;
  3746.  yyt->Formal_generics1.Formal_generics = pFormal_generics;
  3747.  return yyt;
  3748. }
  3749.  
  3750. tTree mFormal_generic
  3751. # if defined __STDC__ | defined __cplusplus
  3752. (tTree pId, tTree pConstraint)
  3753. # else
  3754. (pId, pConstraint)
  3755. tTree pId;
  3756. tTree pConstraint;
  3757. # endif
  3758. {
  3759.  register tTree yyt;
  3760.  yyALLOC (yyt, Tree_NodeSize [kFormal_generic])
  3761.  yyt->Kind = kFormal_generic;
  3762.  yyt->yyHead.yyMark = 0;
  3763.  yyt->Formal_generic.Id = pId;
  3764.  yyt->Formal_generic.Constraint = pConstraint;
  3765.  return yyt;
  3766. }
  3767.  
  3768. tTree mConstraint
  3769. # if defined __STDC__ | defined __cplusplus
  3770. ()
  3771. # else
  3772. ()
  3773. # endif
  3774. {
  3775.  register tTree yyt;
  3776.  yyALLOC (yyt, Tree_NodeSize [kConstraint])
  3777.  yyt->Kind = kConstraint;
  3778.  yyt->yyHead.yyMark = 0;
  3779.  return yyt;
  3780. }
  3781.  
  3782. tTree mConstraint0
  3783. # if defined __STDC__ | defined __cplusplus
  3784. ()
  3785. # else
  3786. ()
  3787. # endif
  3788. {
  3789.  register tTree yyt;
  3790.  yyALLOC (yyt, Tree_NodeSize [kConstraint0])
  3791.  yyt->Kind = kConstraint0;
  3792.  yyt->yyHead.yyMark = 0;
  3793.  return yyt;
  3794. }
  3795.  
  3796. tTree mConstraint1
  3797. # if defined __STDC__ | defined __cplusplus
  3798. (tTree pClass_type)
  3799. # else
  3800. (pClass_type)
  3801. tTree pClass_type;
  3802. # endif
  3803. {
  3804.  register tTree yyt;
  3805.  yyALLOC (yyt, Tree_NodeSize [kConstraint1])
  3806.  yyt->Kind = kConstraint1;
  3807.  yyt->yyHead.yyMark = 0;
  3808.  yyt->Constraint1.Class_type = pClass_type;
  3809.  return yyt;
  3810. }
  3811.  
  3812. tTree mCompound
  3813. # if defined __STDC__ | defined __cplusplus
  3814. ()
  3815. # else
  3816. ()
  3817. # endif
  3818. {
  3819.  register tTree yyt;
  3820.  yyALLOC (yyt, Tree_NodeSize [kCompound])
  3821.  yyt->Kind = kCompound;
  3822.  yyt->yyHead.yyMark = 0;
  3823.  return yyt;
  3824. }
  3825.  
  3826. tTree mCompound0
  3827. # if defined __STDC__ | defined __cplusplus
  3828. ()
  3829. # else
  3830. ()
  3831. # endif
  3832. {
  3833.  register tTree yyt;
  3834.  yyALLOC (yyt, Tree_NodeSize [kCompound0])
  3835.  yyt->Kind = kCompound0;
  3836.  yyt->yyHead.yyMark = 0;
  3837.  return yyt;
  3838. }
  3839.  
  3840. tTree mCompound1
  3841. # if defined __STDC__ | defined __cplusplus
  3842. (tTree pInstruction, tTree pCompound)
  3843. # else
  3844. (pInstruction, pCompound)
  3845. tTree pInstruction;
  3846. tTree pCompound;
  3847. # endif
  3848. {
  3849.  register tTree yyt;
  3850.  yyALLOC (yyt, Tree_NodeSize [kCompound1])
  3851.  yyt->Kind = kCompound1;
  3852.  yyt->yyHead.yyMark = 0;
  3853.  yyt->Compound1.Instruction = pInstruction;
  3854.  yyt->Compound1.Compound = pCompound;
  3855.  return yyt;
  3856. }
  3857.  
  3858. tTree mThen_part_list
  3859. # if defined __STDC__ | defined __cplusplus
  3860. ()
  3861. # else
  3862. ()
  3863. # endif
  3864. {
  3865.  register tTree yyt;
  3866.  yyALLOC (yyt, Tree_NodeSize [kThen_part_list])
  3867.  yyt->Kind = kThen_part_list;
  3868.  yyt->yyHead.yyMark = 0;
  3869.  return yyt;
  3870. }
  3871.  
  3872. tTree mThen_part_list0
  3873. # if defined __STDC__ | defined __cplusplus
  3874. ()
  3875. # else
  3876. ()
  3877. # endif
  3878. {
  3879.  register tTree yyt;
  3880.  yyALLOC (yyt, Tree_NodeSize [kThen_part_list0])
  3881.  yyt->Kind = kThen_part_list0;
  3882.  yyt->yyHead.yyMark = 0;
  3883.  return yyt;
  3884. }
  3885.  
  3886. tTree mThen_part_list1
  3887. # if defined __STDC__ | defined __cplusplus
  3888. (tTree pThen_part, tTree pThen_part_list)
  3889. # else
  3890. (pThen_part, pThen_part_list)
  3891. tTree pThen_part;
  3892. tTree pThen_part_list;
  3893. # endif
  3894. {
  3895.  register tTree yyt;
  3896.  yyALLOC (yyt, Tree_NodeSize [kThen_part_list1])
  3897.  yyt->Kind = kThen_part_list1;
  3898.  yyt->yyHead.yyMark = 0;
  3899.  yyt->Then_part_list1.Then_part = pThen_part;
  3900.  yyt->Then_part_list1.Then_part_list = pThen_part_list;
  3901.  return yyt;
  3902. }
  3903.  
  3904. tTree mThen_part
  3905. # if defined __STDC__ | defined __cplusplus
  3906. (tTree pGuard, tTree pCompound)
  3907. # else
  3908. (pGuard, pCompound)
  3909. tTree pGuard;
  3910. tTree pCompound;
  3911. # endif
  3912. {
  3913.  register tTree yyt;
  3914.  yyALLOC (yyt, Tree_NodeSize [kThen_part])
  3915.  yyt->Kind = kThen_part;
  3916.  yyt->yyHead.yyMark = 0;
  3917.  yyt->Then_part.Guard = pGuard;
  3918.  yyt->Then_part.Compound = pCompound;
  3919.  return yyt;
  3920. }
  3921.  
  3922. tTree mWhen_part_list
  3923. # if defined __STDC__ | defined __cplusplus
  3924. ()
  3925. # else
  3926. ()
  3927. # endif
  3928. {
  3929.  register tTree yyt;
  3930.  yyALLOC (yyt, Tree_NodeSize [kWhen_part_list])
  3931.  yyt->Kind = kWhen_part_list;
  3932.  yyt->yyHead.yyMark = 0;
  3933.  return yyt;
  3934. }
  3935.  
  3936. tTree mWhen_part_list0
  3937. # if defined __STDC__ | defined __cplusplus
  3938. ()
  3939. # else
  3940. ()
  3941. # endif
  3942. {
  3943.  register tTree yyt;
  3944.  yyALLOC (yyt, Tree_NodeSize [kWhen_part_list0])
  3945.  yyt->Kind = kWhen_part_list0;
  3946.  yyt->yyHead.yyMark = 0;
  3947.  return yyt;
  3948. }
  3949.  
  3950. tTree mWhen_part_list1
  3951. # if defined __STDC__ | defined __cplusplus
  3952. (tTree pWhen_part, tTree pWhen_part_list)
  3953. # else
  3954. (pWhen_part, pWhen_part_list)
  3955. tTree pWhen_part;
  3956. tTree pWhen_part_list;
  3957. # endif
  3958. {
  3959.  register tTree yyt;
  3960.  yyALLOC (yyt, Tree_NodeSize [kWhen_part_list1])
  3961.  yyt->Kind = kWhen_part_list1;
  3962.  yyt->yyHead.yyMark = 0;
  3963.  yyt->When_part_list1.When_part = pWhen_part;
  3964.  yyt->When_part_list1.When_part_list = pWhen_part_list;
  3965.  return yyt;
  3966. }
  3967.  
  3968. tTree mWhen_part
  3969. # if defined __STDC__ | defined __cplusplus
  3970. (tTree pChoices, tTree pCompound)
  3971. # else
  3972. (pChoices, pCompound)
  3973. tTree pChoices;
  3974. tTree pCompound;
  3975. # endif
  3976. {
  3977.  register tTree yyt;
  3978.  yyALLOC (yyt, Tree_NodeSize [kWhen_part])
  3979.  yyt->Kind = kWhen_part;
  3980.  yyt->yyHead.yyMark = 0;
  3981.  yyt->When_part.Choices = pChoices;
  3982.  yyt->When_part.Compound = pCompound;
  3983.  return yyt;
  3984. }
  3985.  
  3986. tTree mChoices
  3987. # if defined __STDC__ | defined __cplusplus
  3988. ()
  3989. # else
  3990. ()
  3991. # endif
  3992. {
  3993.  register tTree yyt;
  3994.  yyALLOC (yyt, Tree_NodeSize [kChoices])
  3995.  yyt->Kind = kChoices;
  3996.  yyt->yyHead.yyMark = 0;
  3997.  return yyt;
  3998. }
  3999.  
  4000. tTree mChoices0
  4001. # if defined __STDC__ | defined __cplusplus
  4002. ()
  4003. # else
  4004. ()
  4005. # endif
  4006. {
  4007.  register tTree yyt;
  4008.  yyALLOC (yyt, Tree_NodeSize [kChoices0])
  4009.  yyt->Kind = kChoices0;
  4010.  yyt->yyHead.yyMark = 0;
  4011.  return yyt;
  4012. }
  4013.  
  4014. tTree mChoices1
  4015. # if defined __STDC__ | defined __cplusplus
  4016. (tTree pChoice, tTree pChoices)
  4017. # else
  4018. (pChoice, pChoices)
  4019. tTree pChoice;
  4020. tTree pChoices;
  4021. # endif
  4022. {
  4023.  register tTree yyt;
  4024.  yyALLOC (yyt, Tree_NodeSize [kChoices1])
  4025.  yyt->Kind = kChoices1;
  4026.  yyt->yyHead.yyMark = 0;
  4027.  yyt->Choices1.Choice = pChoice;
  4028.  yyt->Choices1.Choices = pChoices;
  4029.  return yyt;
  4030. }
  4031.  
  4032. tTree mChoice
  4033. # if defined __STDC__ | defined __cplusplus
  4034. ()
  4035. # else
  4036. ()
  4037. # endif
  4038. {
  4039.  register tTree yyt;
  4040.  yyALLOC (yyt, Tree_NodeSize [kChoice])
  4041.  yyt->Kind = kChoice;
  4042.  yyt->yyHead.yyMark = 0;
  4043.  return yyt;
  4044. }
  4045.  
  4046. tTree mInterval
  4047. # if defined __STDC__ | defined __cplusplus
  4048. (tTree pFrom, tTree pTo)
  4049. # else
  4050. (pFrom, pTo)
  4051. tTree pFrom;
  4052. tTree pTo;
  4053. # endif
  4054. {
  4055.  register tTree yyt;
  4056.  yyALLOC (yyt, Tree_NodeSize [kInterval])
  4057.  yyt->Kind = kInterval;
  4058.  yyt->yyHead.yyMark = 0;
  4059.  yyt->Interval.From = pFrom;
  4060.  yyt->Interval.To = pTo;
  4061.  return yyt;
  4062. }
  4063.  
  4064. tTree mVal
  4065. # if defined __STDC__ | defined __cplusplus
  4066. (tTree pManifest_constant)
  4067. # else
  4068. (pManifest_constant)
  4069. tTree pManifest_constant;
  4070. # endif
  4071. {
  4072.  register tTree yyt;
  4073.  yyALLOC (yyt, Tree_NodeSize [kVal])
  4074.  yyt->Kind = kVal;
  4075.  yyt->yyHead.yyMark = 0;
  4076.  yyt->Val.Manifest_constant = pManifest_constant;
  4077.  return yyt;
  4078. }
  4079.  
  4080. tTree mInstruction
  4081. # if defined __STDC__ | defined __cplusplus
  4082. ()
  4083. # else
  4084. ()
  4085. # endif
  4086. {
  4087.  register tTree yyt;
  4088.  yyALLOC (yyt, Tree_NodeSize [kInstruction])
  4089.  yyt->Kind = kInstruction;
  4090.  yyt->yyHead.yyMark = 0;
  4091.  return yyt;
  4092. }
  4093.  
  4094. tTree mInstruction0
  4095. # if defined __STDC__ | defined __cplusplus
  4096. ()
  4097. # else
  4098. ()
  4099. # endif
  4100. {
  4101.  register tTree yyt;
  4102.  yyALLOC (yyt, Tree_NodeSize [kInstruction0])
  4103.  yyt->Kind = kInstruction0;
  4104.  yyt->yyHead.yyMark = 0;
  4105.  return yyt;
  4106. }
  4107.  
  4108. tTree mCreation
  4109. # if defined __STDC__ | defined __cplusplus
  4110. (tTree pType, tTree pEntity, tTree pUnqual_call)
  4111. # else
  4112. (pType, pEntity, pUnqual_call)
  4113. tTree pType;
  4114. tTree pEntity;
  4115. tTree pUnqual_call;
  4116. # endif
  4117. {
  4118.  register tTree yyt;
  4119.  yyALLOC (yyt, Tree_NodeSize [kCreation])
  4120.  yyt->Kind = kCreation;
  4121.  yyt->yyHead.yyMark = 0;
  4122.  yyt->Creation.Type = pType;
  4123.  yyt->Creation.Entity = pEntity;
  4124.  yyt->Creation.Unqual_call = pUnqual_call;
  4125.  return yyt;
  4126. }
  4127.  
  4128. tTree mCall_instruct
  4129. # if defined __STDC__ | defined __cplusplus
  4130. (tTree pCall)
  4131. # else
  4132. (pCall)
  4133. tTree pCall;
  4134. # endif
  4135. {
  4136.  register tTree yyt;
  4137.  yyALLOC (yyt, Tree_NodeSize [kCall_instruct])
  4138.  yyt->Kind = kCall_instruct;
  4139.  yyt->yyHead.yyMark = 0;
  4140.  yyt->Call_instruct.Call = pCall;
  4141.  return yyt;
  4142. }
  4143.  
  4144. tTree mAssign
  4145. # if defined __STDC__ | defined __cplusplus
  4146. (tTree pAddr, tTree pExpression)
  4147. # else
  4148. (pAddr, pExpression)
  4149. tTree pAddr;
  4150. tTree pExpression;
  4151. # endif
  4152. {
  4153.  register tTree yyt;
  4154.  yyALLOC (yyt, Tree_NodeSize [kAssign])
  4155.  yyt->Kind = kAssign;
  4156.  yyt->yyHead.yyMark = 0;
  4157.  yyt->Assign.Addr = pAddr;
  4158.  yyt->Assign.Expression = pExpression;
  4159.  return yyt;
  4160. }
  4161.  
  4162. tTree mRev_assign
  4163. # if defined __STDC__ | defined __cplusplus
  4164. (tTree pAddr, tTree pExpression)
  4165. # else
  4166. (pAddr, pExpression)
  4167. tTree pAddr;
  4168. tTree pExpression;
  4169. # endif
  4170. {
  4171.  register tTree yyt;
  4172.  yyALLOC (yyt, Tree_NodeSize [kRev_assign])
  4173.  yyt->Kind = kRev_assign;
  4174.  yyt->yyHead.yyMark = 0;
  4175.  yyt->Rev_assign.Addr = pAddr;
  4176.  yyt->Rev_assign.Expression = pExpression;
  4177.  return yyt;
  4178. }
  4179.  
  4180. tTree mConditional
  4181. # if defined __STDC__ | defined __cplusplus
  4182. (tTree pThen_part, tTree pElse_part)
  4183. # else
  4184. (pThen_part, pElse_part)
  4185. tTree pThen_part;
  4186. tTree pElse_part;
  4187. # endif
  4188. {
  4189.  register tTree yyt;
  4190.  yyALLOC (yyt, Tree_NodeSize [kConditional])
  4191.  yyt->Kind = kConditional;
  4192.  yyt->yyHead.yyMark = 0;
  4193.  yyt->Conditional.Then_part = pThen_part;
  4194.  yyt->Conditional.Else_part = pElse_part;
  4195.  return yyt;
  4196. }
  4197.  
  4198. tTree mMulti_branch
  4199. # if defined __STDC__ | defined __cplusplus
  4200. (tTree pGuard, tTree pWhen_part_list, tTree pElse_part)
  4201. # else
  4202. (pGuard, pWhen_part_list, pElse_part)
  4203. tTree pGuard;
  4204. tTree pWhen_part_list;
  4205. tTree pElse_part;
  4206. # endif
  4207. {
  4208.  register tTree yyt;
  4209.  yyALLOC (yyt, Tree_NodeSize [kMulti_branch])
  4210.  yyt->Kind = kMulti_branch;
  4211.  yyt->yyHead.yyMark = 0;
  4212.  yyt->Multi_branch.Guard = pGuard;
  4213.  yyt->Multi_branch.When_part_list = pWhen_part_list;
  4214.  yyt->Multi_branch.Else_part = pElse_part;
  4215.  return yyt;
  4216. }
  4217.  
  4218. tTree mLoop
  4219. # if defined __STDC__ | defined __cplusplus
  4220. (tTree pInitialization, tTree pInvariant, tTree pVariant, tTree pLoop_body)
  4221. # else
  4222. (pInitialization, pInvariant, pVariant, pLoop_body)
  4223. tTree pInitialization;
  4224. tTree pInvariant;
  4225. tTree pVariant;
  4226. tTree pLoop_body;
  4227. # endif
  4228. {
  4229.  register tTree yyt;
  4230.  yyALLOC (yyt, Tree_NodeSize [kLoop])
  4231.  yyt->Kind = kLoop;
  4232.  yyt->yyHead.yyMark = 0;
  4233.  yyt->Loop.Initialization = pInitialization;
  4234.  yyt->Loop.Invariant = pInvariant;
  4235.  yyt->Loop.Variant = pVariant;
  4236.  yyt->Loop.Loop_body = pLoop_body;
  4237.  return yyt;
  4238. }
  4239.  
  4240. tTree mCheck
  4241. # if defined __STDC__ | defined __cplusplus
  4242. (tTree pAssertion)
  4243. # else
  4244. (pAssertion)
  4245. tTree pAssertion;
  4246. # endif
  4247. {
  4248.  register tTree yyt;
  4249.  yyALLOC (yyt, Tree_NodeSize [kCheck])
  4250.  yyt->Kind = kCheck;
  4251.  yyt->yyHead.yyMark = 0;
  4252.  yyt->Check.Assertion = pAssertion;
  4253.  return yyt;
  4254. }
  4255.  
  4256. tTree mDebug
  4257. # if defined __STDC__ | defined __cplusplus
  4258. (tTree pDebug_keys, tTree pCompound)
  4259. # else
  4260. (pDebug_keys, pCompound)
  4261. tTree pDebug_keys;
  4262. tTree pCompound;
  4263. # endif
  4264. {
  4265.  register tTree yyt;
  4266.  yyALLOC (yyt, Tree_NodeSize [kDebug])
  4267.  yyt->Kind = kDebug;
  4268.  yyt->yyHead.yyMark = 0;
  4269.  yyt->Debug.Debug_keys = pDebug_keys;
  4270.  yyt->Debug.Compound = pCompound;
  4271.  return yyt;
  4272. }
  4273.  
  4274. tTree mRetry
  4275. # if defined __STDC__ | defined __cplusplus
  4276. (tPosition ppos)
  4277. # else
  4278. (ppos)
  4279. tPosition ppos;
  4280. # endif
  4281. {
  4282.  register tTree yyt;
  4283.  yyALLOC (yyt, Tree_NodeSize [kRetry])
  4284.  yyt->Kind = kRetry;
  4285.  yyt->yyHead.yyMark = 0;
  4286.  yyt->Retry.pos = ppos;
  4287.  return yyt;
  4288. }
  4289.  
  4290. tTree mLoop_body
  4291. # if defined __STDC__ | defined __cplusplus
  4292. ()
  4293. # else
  4294. ()
  4295. # endif
  4296. {
  4297.  register tTree yyt;
  4298.  yyALLOC (yyt, Tree_NodeSize [kLoop_body])
  4299.  yyt->Kind = kLoop_body;
  4300.  yyt->yyHead.yyMark = 0;
  4301.  return yyt;
  4302. }
  4303.  
  4304. tTree mLoop_body0
  4305. # if defined __STDC__ | defined __cplusplus
  4306. ()
  4307. # else
  4308. ()
  4309. # endif
  4310. {
  4311.  register tTree yyt;
  4312.  yyALLOC (yyt, Tree_NodeSize [kLoop_body0])
  4313.  yyt->Kind = kLoop_body0;
  4314.  yyt->yyHead.yyMark = 0;
  4315.  return yyt;
  4316. }
  4317.  
  4318. tTree mLoop_body1
  4319. # if defined __STDC__ | defined __cplusplus
  4320. (tTree pExit, tTree pCompound)
  4321. # else
  4322. (pExit, pCompound)
  4323. tTree pExit;
  4324. tTree pCompound;
  4325. # endif
  4326. {
  4327.  register tTree yyt;
  4328.  yyALLOC (yyt, Tree_NodeSize [kLoop_body1])
  4329.  yyt->Kind = kLoop_body1;
  4330.  yyt->yyHead.yyMark = 0;
  4331.  yyt->Loop_body1.Exit = pExit;
  4332.  yyt->Loop_body1.Compound = pCompound;
  4333.  return yyt;
  4334. }
  4335.  
  4336. tTree mType
  4337. # if defined __STDC__ | defined __cplusplus
  4338. ()
  4339. # else
  4340. ()
  4341. # endif
  4342. {
  4343.  register tTree yyt;
  4344.  yyALLOC (yyt, Tree_NodeSize [kType])
  4345.  yyt->Kind = kType;
  4346.  yyt->yyHead.yyMark = 0;
  4347.  return yyt;
  4348. }
  4349.  
  4350. tTree mType0
  4351. # if defined __STDC__ | defined __cplusplus
  4352. ()
  4353. # else
  4354. ()
  4355. # endif
  4356. {
  4357.  register tTree yyt;
  4358.  yyALLOC (yyt, Tree_NodeSize [kType0])
  4359.  yyt->Kind = kType0;
  4360.  yyt->yyHead.yyMark = 0;
  4361.  return yyt;
  4362. }
  4363.  
  4364. tTree mClass_type
  4365. # if defined __STDC__ | defined __cplusplus
  4366. (tTree pId, tTree pActual_generics)
  4367. # else
  4368. (pId, pActual_generics)
  4369. tTree pId;
  4370. tTree pActual_generics;
  4371. # endif
  4372. {
  4373.  register tTree yyt;
  4374.  yyALLOC (yyt, Tree_NodeSize [kClass_type])
  4375.  yyt->Kind = kClass_type;
  4376.  yyt->yyHead.yyMark = 0;
  4377.  yyt->Class_type.Id = pId;
  4378.  yyt->Class_type.Actual_generics = pActual_generics;
  4379.  return yyt;
  4380. }
  4381.  
  4382. tTree mClass_type_expanded
  4383. # if defined __STDC__ | defined __cplusplus
  4384. (tTree pId, tTree pActual_generics)
  4385. # else
  4386. (pId, pActual_generics)
  4387. tTree pId;
  4388. tTree pActual_generics;
  4389. # endif
  4390. {
  4391.  register tTree yyt;
  4392.  yyALLOC (yyt, Tree_NodeSize [kClass_type_expanded])
  4393.  yyt->Kind = kClass_type_expanded;
  4394.  yyt->yyHead.yyMark = 0;
  4395.  yyt->Class_type_expanded.Id = pId;
  4396.  yyt->Class_type_expanded.Actual_generics = pActual_generics;
  4397.  return yyt;
  4398. }
  4399.  
  4400. tTree mBit_type
  4401. # if defined __STDC__ | defined __cplusplus
  4402. (tTree pManifest_constant)
  4403. # else
  4404. (pManifest_constant)
  4405. tTree pManifest_constant;
  4406. # endif
  4407. {
  4408.  register tTree yyt;
  4409.  yyALLOC (yyt, Tree_NodeSize [kBit_type])
  4410.  yyt->Kind = kBit_type;
  4411.  yyt->yyHead.yyMark = 0;
  4412.  yyt->Bit_type.Manifest_constant = pManifest_constant;
  4413.  return yyt;
  4414. }
  4415.  
  4416. tTree mSimple_type
  4417. # if defined __STDC__ | defined __cplusplus
  4418. (tTree pManifest_constant)
  4419. # else
  4420. (pManifest_constant)
  4421. tTree pManifest_constant;
  4422. # endif
  4423. {
  4424.  register tTree yyt;
  4425.  yyALLOC (yyt, Tree_NodeSize [kSimple_type])
  4426.  yyt->Kind = kSimple_type;
  4427.  yyt->yyHead.yyMark = 0;
  4428.  yyt->Simple_type.Manifest_constant = pManifest_constant;
  4429.  return yyt;
  4430. }
  4431.  
  4432. tTree mAnchored
  4433. # if defined __STDC__ | defined __cplusplus
  4434. (tTree pEntity)
  4435. # else
  4436. (pEntity)
  4437. tTree pEntity;
  4438. # endif
  4439. {
  4440.  register tTree yyt;
  4441.  yyALLOC (yyt, Tree_NodeSize [kAnchored])
  4442.  yyt->Kind = kAnchored;
  4443.  yyt->yyHead.yyMark = 0;
  4444.  yyt->Anchored.Entity = pEntity;
  4445.  return yyt;
  4446. }
  4447.  
  4448. tTree mActual_generics
  4449. # if defined __STDC__ | defined __cplusplus
  4450. ()
  4451. # else
  4452. ()
  4453. # endif
  4454. {
  4455.  register tTree yyt;
  4456.  yyALLOC (yyt, Tree_NodeSize [kActual_generics])
  4457.  yyt->Kind = kActual_generics;
  4458.  yyt->yyHead.yyMark = 0;
  4459.  return yyt;
  4460. }
  4461.  
  4462. tTree mActual_generics0
  4463. # if defined __STDC__ | defined __cplusplus
  4464. ()
  4465. # else
  4466. ()
  4467. # endif
  4468. {
  4469.  register tTree yyt;
  4470.  yyALLOC (yyt, Tree_NodeSize [kActual_generics0])
  4471.  yyt->Kind = kActual_generics0;
  4472.  yyt->yyHead.yyMark = 0;
  4473.  return yyt;
  4474. }
  4475.  
  4476. tTree mActual_generics1
  4477. # if defined __STDC__ | defined __cplusplus
  4478. (tTree pType_list)
  4479. # else
  4480. (pType_list)
  4481. tTree pType_list;
  4482. # endif
  4483. {
  4484.  register tTree yyt;
  4485.  yyALLOC (yyt, Tree_NodeSize [kActual_generics1])
  4486.  yyt->Kind = kActual_generics1;
  4487.  yyt->yyHead.yyMark = 0;
  4488.  yyt->Actual_generics1.Type_list = pType_list;
  4489.  return yyt;
  4490. }
  4491.  
  4492. tTree mCondition
  4493. # if defined __STDC__ | defined __cplusplus
  4494. ()
  4495. # else
  4496. ()
  4497. # endif
  4498. {
  4499.  register tTree yyt;
  4500.  yyALLOC (yyt, Tree_NodeSize [kCondition])
  4501.  yyt->Kind = kCondition;
  4502.  yyt->yyHead.yyMark = 0;
  4503.  return yyt;
  4504. }
  4505.  
  4506. tTree mCondition0
  4507. # if defined __STDC__ | defined __cplusplus
  4508. ()
  4509. # else
  4510. ()
  4511. # endif
  4512. {
  4513.  register tTree yyt;
  4514.  yyALLOC (yyt, Tree_NodeSize [kCondition0])
  4515.  yyt->Kind = kCondition0;
  4516.  yyt->yyHead.yyMark = 0;
  4517.  return yyt;
  4518. }
  4519.  
  4520. tTree mCondition1
  4521. # if defined __STDC__ | defined __cplusplus
  4522. (int pextension, tTree pAssertion)
  4523. # else
  4524. (pextension, pAssertion)
  4525. int pextension;
  4526. tTree pAssertion;
  4527. # endif
  4528. {
  4529.  register tTree yyt;
  4530.  yyALLOC (yyt, Tree_NodeSize [kCondition1])
  4531.  yyt->Kind = kCondition1;
  4532.  yyt->yyHead.yyMark = 0;
  4533.  yyt->Condition1.extension = pextension;
  4534.  yyt->Condition1.Assertion = pAssertion;
  4535.  return yyt;
  4536. }
  4537.  
  4538. tTree mAssertion
  4539. # if defined __STDC__ | defined __cplusplus
  4540. ()
  4541. # else
  4542. ()
  4543. # endif
  4544. {
  4545.  register tTree yyt;
  4546.  yyALLOC (yyt, Tree_NodeSize [kAssertion])
  4547.  yyt->Kind = kAssertion;
  4548.  yyt->yyHead.yyMark = 0;
  4549.  return yyt;
  4550. }
  4551.  
  4552. tTree mAssertion0
  4553. # if defined __STDC__ | defined __cplusplus
  4554. ()
  4555. # else
  4556. ()
  4557. # endif
  4558. {
  4559.  register tTree yyt;
  4560.  yyALLOC (yyt, Tree_NodeSize [kAssertion0])
  4561.  yyt->Kind = kAssertion0;
  4562.  yyt->yyHead.yyMark = 0;
  4563.  return yyt;
  4564. }
  4565.  
  4566. tTree mAssertion1
  4567. # if defined __STDC__ | defined __cplusplus
  4568. (tTree pAssertion_clause, tTree pAssertion)
  4569. # else
  4570. (pAssertion_clause, pAssertion)
  4571. tTree pAssertion_clause;
  4572. tTree pAssertion;
  4573. # endif
  4574. {
  4575.  register tTree yyt;
  4576.  yyALLOC (yyt, Tree_NodeSize [kAssertion1])
  4577.  yyt->Kind = kAssertion1;
  4578.  yyt->yyHead.yyMark = 0;
  4579.  yyt->Assertion1.Assertion_clause = pAssertion_clause;
  4580.  yyt->Assertion1.Assertion = pAssertion;
  4581.  return yyt;
  4582. }
  4583.  
  4584. tTree mAssertion_clause
  4585. # if defined __STDC__ | defined __cplusplus
  4586. ()
  4587. # else
  4588. ()
  4589. # endif
  4590. {
  4591.  register tTree yyt;
  4592.  yyALLOC (yyt, Tree_NodeSize [kAssertion_clause])
  4593.  yyt->Kind = kAssertion_clause;
  4594.  yyt->yyHead.yyMark = 0;
  4595.  return yyt;
  4596. }
  4597.  
  4598. tTree mAssertion_clause0
  4599. # if defined __STDC__ | defined __cplusplus
  4600. ()
  4601. # else
  4602. ()
  4603. # endif
  4604. {
  4605.  register tTree yyt;
  4606.  yyALLOC (yyt, Tree_NodeSize [kAssertion_clause0])
  4607.  yyt->Kind = kAssertion_clause0;
  4608.  yyt->yyHead.yyMark = 0;
  4609.  return yyt;
  4610. }
  4611.  
  4612. tTree mAssertion_clause1
  4613. # if defined __STDC__ | defined __cplusplus
  4614. (tTree pTag, tTree pExpression)
  4615. # else
  4616. (pTag, pExpression)
  4617. tTree pTag;
  4618. tTree pExpression;
  4619. # endif
  4620. {
  4621.  register tTree yyt;
  4622.  yyALLOC (yyt, Tree_NodeSize [kAssertion_clause1])
  4623.  yyt->Kind = kAssertion_clause1;
  4624.  yyt->yyHead.yyMark = 0;
  4625.  yyt->Assertion_clause1.Tag = pTag;
  4626.  yyt->Assertion_clause1.Expression = pExpression;
  4627.  return yyt;
  4628. }
  4629.  
  4630. tTree mType_list
  4631. # if defined __STDC__ | defined __cplusplus
  4632. ()
  4633. # else
  4634. ()
  4635. # endif
  4636. {
  4637.  register tTree yyt;
  4638.  yyALLOC (yyt, Tree_NodeSize [kType_list])
  4639.  yyt->Kind = kType_list;
  4640.  yyt->yyHead.yyMark = 0;
  4641.  return yyt;
  4642. }
  4643.  
  4644. tTree mType_list0
  4645. # if defined __STDC__ | defined __cplusplus
  4646. ()
  4647. # else
  4648. ()
  4649. # endif
  4650. {
  4651.  register tTree yyt;
  4652.  yyALLOC (yyt, Tree_NodeSize [kType_list0])
  4653.  yyt->Kind = kType_list0;
  4654.  yyt->yyHead.yyMark = 0;
  4655.  return yyt;
  4656. }
  4657.  
  4658. tTree mType_list1
  4659. # if defined __STDC__ | defined __cplusplus
  4660. (tTree pType, tTree pType_list)
  4661. # else
  4662. (pType, pType_list)
  4663. tTree pType;
  4664. tTree pType_list;
  4665. # endif
  4666. {
  4667.  register tTree yyt;
  4668.  yyALLOC (yyt, Tree_NodeSize [kType_list1])
  4669.  yyt->Kind = kType_list1;
  4670.  yyt->yyHead.yyMark = 0;
  4671.  yyt->Type_list1.Type = pType;
  4672.  yyt->Type_list1.Type_list = pType_list;
  4673.  return yyt;
  4674. }
  4675.  
  4676. tTree mCall_chain
  4677. # if defined __STDC__ | defined __cplusplus
  4678. ()
  4679. # else
  4680. ()
  4681. # endif
  4682. {
  4683.  register tTree yyt;
  4684.  yyALLOC (yyt, Tree_NodeSize [kCall_chain])
  4685.  yyt->Kind = kCall_chain;
  4686.  yyt->yyHead.yyMark = 0;
  4687.  return yyt;
  4688. }
  4689.  
  4690. tTree mCall_chain0
  4691. # if defined __STDC__ | defined __cplusplus
  4692. ()
  4693. # else
  4694. ()
  4695. # endif
  4696. {
  4697.  register tTree yyt;
  4698.  yyALLOC (yyt, Tree_NodeSize [kCall_chain0])
  4699.  yyt->Kind = kCall_chain0;
  4700.  yyt->yyHead.yyMark = 0;
  4701.  return yyt;
  4702. }
  4703.  
  4704. tTree mCall_chain1
  4705. # if defined __STDC__ | defined __cplusplus
  4706. (tTree pUnqual_call, tTree pCall_chain)
  4707. # else
  4708. (pUnqual_call, pCall_chain)
  4709. tTree pUnqual_call;
  4710. tTree pCall_chain;
  4711. # endif
  4712. {
  4713.  register tTree yyt;
  4714.  yyALLOC (yyt, Tree_NodeSize [kCall_chain1])
  4715.  yyt->Kind = kCall_chain1;
  4716.  yyt->yyHead.yyMark = 0;
  4717.  yyt->Call_chain1.Unqual_call = pUnqual_call;
  4718.  yyt->Call_chain1.Call_chain = pCall_chain;
  4719.  return yyt;
  4720. }
  4721.  
  4722. tTree mUnqual_call
  4723. # if defined __STDC__ | defined __cplusplus
  4724. ()
  4725. # else
  4726. ()
  4727. # endif
  4728. {
  4729.  register tTree yyt;
  4730.  yyALLOC (yyt, Tree_NodeSize [kUnqual_call])
  4731.  yyt->Kind = kUnqual_call;
  4732.  yyt->yyHead.yyMark = 0;
  4733.  return yyt;
  4734. }
  4735.  
  4736. tTree mUnqual_call0
  4737. # if defined __STDC__ | defined __cplusplus
  4738. ()
  4739. # else
  4740. ()
  4741. # endif
  4742. {
  4743.  register tTree yyt;
  4744.  yyALLOC (yyt, Tree_NodeSize [kUnqual_call0])
  4745.  yyt->Kind = kUnqual_call0;
  4746.  yyt->yyHead.yyMark = 0;
  4747.  return yyt;
  4748. }
  4749.  
  4750. tTree mUnqual_call1
  4751. # if defined __STDC__ | defined __cplusplus
  4752. (tTree pEntity, tTree pActuals)
  4753. # else
  4754. (pEntity, pActuals)
  4755. tTree pEntity;
  4756. tTree pActuals;
  4757. # endif
  4758. {
  4759.  register tTree yyt;
  4760.  yyALLOC (yyt, Tree_NodeSize [kUnqual_call1])
  4761.  yyt->Kind = kUnqual_call1;
  4762.  yyt->yyHead.yyMark = 0;
  4763.  yyt->Unqual_call1.Entity = pEntity;
  4764.  yyt->Unqual_call1.Actuals = pActuals;
  4765.  return yyt;
  4766. }
  4767.  
  4768. tTree mActuals
  4769. # if defined __STDC__ | defined __cplusplus
  4770. ()
  4771. # else
  4772. ()
  4773. # endif
  4774. {
  4775.  register tTree yyt;
  4776.  yyALLOC (yyt, Tree_NodeSize [kActuals])
  4777.  yyt->Kind = kActuals;
  4778.  yyt->yyHead.yyMark = 0;
  4779.  return yyt;
  4780. }
  4781.  
  4782. tTree mActuals0
  4783. # if defined __STDC__ | defined __cplusplus
  4784. ()
  4785. # else
  4786. ()
  4787. # endif
  4788. {
  4789.  register tTree yyt;
  4790.  yyALLOC (yyt, Tree_NodeSize [kActuals0])
  4791.  yyt->Kind = kActuals0;
  4792.  yyt->yyHead.yyMark = 0;
  4793.  return yyt;
  4794. }
  4795.  
  4796. tTree mActuals1
  4797. # if defined __STDC__ | defined __cplusplus
  4798. (tTree pActual_list)
  4799. # else
  4800. (pActual_list)
  4801. tTree pActual_list;
  4802. # endif
  4803. {
  4804.  register tTree yyt;
  4805.  yyALLOC (yyt, Tree_NodeSize [kActuals1])
  4806.  yyt->Kind = kActuals1;
  4807.  yyt->yyHead.yyMark = 0;
  4808.  yyt->Actuals1.Actual_list = pActual_list;
  4809.  return yyt;
  4810. }
  4811.  
  4812. tTree mActual_list
  4813. # if defined __STDC__ | defined __cplusplus
  4814. ()
  4815. # else
  4816. ()
  4817. # endif
  4818. {
  4819.  register tTree yyt;
  4820.  yyALLOC (yyt, Tree_NodeSize [kActual_list])
  4821.  yyt->Kind = kActual_list;
  4822.  yyt->yyHead.yyMark = 0;
  4823.  return yyt;
  4824. }
  4825.  
  4826. tTree mActual_list0
  4827. # if defined __STDC__ | defined __cplusplus
  4828. ()
  4829. # else
  4830. ()
  4831. # endif
  4832. {
  4833.  register tTree yyt;
  4834.  yyALLOC (yyt, Tree_NodeSize [kActual_list0])
  4835.  yyt->Kind = kActual_list0;
  4836.  yyt->yyHead.yyMark = 0;
  4837.  return yyt;
  4838. }
  4839.  
  4840. tTree mActual_list1
  4841. # if defined __STDC__ | defined __cplusplus
  4842. (tTree pActual, tTree pActual_list)
  4843. # else
  4844. (pActual, pActual_list)
  4845. tTree pActual;
  4846. tTree pActual_list;
  4847. # endif
  4848. {
  4849.  register tTree yyt;
  4850.  yyALLOC (yyt, Tree_NodeSize [kActual_list1])
  4851.  yyt->Kind = kActual_list1;
  4852.  yyt->yyHead.yyMark = 0;
  4853.  yyt->Actual_list1.Actual = pActual;
  4854.  yyt->Actual_list1.Actual_list = pActual_list;
  4855.  return yyt;
  4856. }
  4857.  
  4858. tTree mActual
  4859. # if defined __STDC__ | defined __cplusplus
  4860. ()
  4861. # else
  4862. ()
  4863. # endif
  4864. {
  4865.  register tTree yyt;
  4866.  yyALLOC (yyt, Tree_NodeSize [kActual])
  4867.  yyt->Kind = kActual;
  4868.  yyt->yyHead.yyMark = 0;
  4869.  return yyt;
  4870. }
  4871.  
  4872. tTree mAddr
  4873. # if defined __STDC__ | defined __cplusplus
  4874. (tTree pEntity)
  4875. # else
  4876. (pEntity)
  4877. tTree pEntity;
  4878. # endif
  4879. {
  4880.  register tTree yyt;
  4881.  yyALLOC (yyt, Tree_NodeSize [kAddr])
  4882.  yyt->Kind = kAddr;
  4883.  yyt->yyHead.yyMark = 0;
  4884.  yyt->Addr.Entity = pEntity;
  4885.  return yyt;
  4886. }
  4887.  
  4888. tTree mExpression
  4889. # if defined __STDC__ | defined __cplusplus
  4890. ()
  4891. # else
  4892. ()
  4893. # endif
  4894. {
  4895.  register tTree yyt;
  4896.  yyALLOC (yyt, Tree_NodeSize [kExpression])
  4897.  yyt->Kind = kExpression;
  4898.  yyt->yyHead.yyMark = 0;
  4899.  return yyt;
  4900. }
  4901.  
  4902. tTree mExpression0
  4903. # if defined __STDC__ | defined __cplusplus
  4904. ()
  4905. # else
  4906. ()
  4907. # endif
  4908. {
  4909.  register tTree yyt;
  4910.  yyALLOC (yyt, Tree_NodeSize [kExpression0])
  4911.  yyt->Kind = kExpression0;
  4912.  yyt->yyHead.yyMark = 0;
  4913.  return yyt;
  4914. }
  4915.  
  4916. tTree mComment
  4917. # if defined __STDC__ | defined __cplusplus
  4918. (tStringRef pcomment)
  4919. # else
  4920. (pcomment)
  4921. tStringRef pcomment;
  4922. # endif
  4923. {
  4924.  register tTree yyt;
  4925.  yyALLOC (yyt, Tree_NodeSize [kComment])
  4926.  yyt->Kind = kComment;
  4927.  yyt->yyHead.yyMark = 0;
  4928.  yyt->Comment.comment = pcomment;
  4929.  return yyt;
  4930. }
  4931.  
  4932. tTree mSimple_expr
  4933. # if defined __STDC__ | defined __cplusplus
  4934. (tTree pManifest_constant)
  4935. # else
  4936. (pManifest_constant)
  4937. tTree pManifest_constant;
  4938. # endif
  4939. {
  4940.  register tTree yyt;
  4941.  yyALLOC (yyt, Tree_NodeSize [kSimple_expr])
  4942.  yyt->Kind = kSimple_expr;
  4943.  yyt->yyHead.yyMark = 0;
  4944.  yyt->Simple_expr.Manifest_constant = pManifest_constant;
  4945.  return yyt;
  4946. }
  4947.  
  4948. tTree mCall
  4949. # if defined __STDC__ | defined __cplusplus
  4950. (tTree pQual, tTree pCall_chain)
  4951. # else
  4952. (pQual, pCall_chain)
  4953. tTree pQual;
  4954. tTree pCall_chain;
  4955. # endif
  4956. {
  4957.  register tTree yyt;
  4958.  yyALLOC (yyt, Tree_NodeSize [kCall])
  4959.  yyt->Kind = kCall;
  4960.  yyt->yyHead.yyMark = 0;
  4961.  yyt->Call.Qual = pQual;
  4962.  yyt->Call.Call_chain = pCall_chain;
  4963.  return yyt;
  4964. }
  4965.  
  4966. tTree mBin_expr
  4967. # if defined __STDC__ | defined __cplusplus
  4968. (tTree pLop, tTree pOp, tTree pRop)
  4969. # else
  4970. (pLop, pOp, pRop)
  4971. tTree pLop;
  4972. tTree pOp;
  4973. tTree pRop;
  4974. # endif
  4975. {
  4976.  register tTree yyt;
  4977.  yyALLOC (yyt, Tree_NodeSize [kBin_expr])
  4978.  yyt->Kind = kBin_expr;
  4979.  yyt->yyHead.yyMark = 0;
  4980.  yyt->Bin_expr.Lop = pLop;
  4981.  yyt->Bin_expr.Op = pOp;
  4982.  yyt->Bin_expr.Rop = pRop;
  4983.  return yyt;
  4984. }
  4985.  
  4986. tTree mUn_expr
  4987. # if defined __STDC__ | defined __cplusplus
  4988. (tTree pOp, tTree pExpression)
  4989. # else
  4990. (pOp, pExpression)
  4991. tTree pOp;
  4992. tTree pExpression;
  4993. # endif
  4994. {
  4995.  register tTree yyt;
  4996.  yyALLOC (yyt, Tree_NodeSize [kUn_expr])
  4997.  yyt->Kind = kUn_expr;
  4998.  yyt->yyHead.yyMark = 0;
  4999.  yyt->Un_expr.Op = pOp;
  5000.  yyt->Un_expr.Expression = pExpression;
  5001.  return yyt;
  5002. }
  5003.  
  5004. tTree mParenth
  5005. # if defined __STDC__ | defined __cplusplus
  5006. (tTree pExpression)
  5007. # else
  5008. (pExpression)
  5009. tTree pExpression;
  5010. # endif
  5011. {
  5012.  register tTree yyt;
  5013.  yyALLOC (yyt, Tree_NodeSize [kParenth])
  5014.  yyt->Kind = kParenth;
  5015.  yyt->yyHead.yyMark = 0;
  5016.  yyt->Parenth.Expression = pExpression;
  5017.  return yyt;
  5018. }
  5019.  
  5020. tTree mManifest_array
  5021. # if defined __STDC__ | defined __cplusplus
  5022. ()
  5023. # else
  5024. ()
  5025. # endif
  5026. {
  5027.  register tTree yyt;
  5028.  yyALLOC (yyt, Tree_NodeSize [kManifest_array])
  5029.  yyt->Kind = kManifest_array;
  5030.  yyt->yyHead.yyMark = 0;
  5031.  return yyt;
  5032. }
  5033.  
  5034. tTree mManifest_array0
  5035. # if defined __STDC__ | defined __cplusplus
  5036. ()
  5037. # else
  5038. ()
  5039. # endif
  5040. {
  5041.  register tTree yyt;
  5042.  yyALLOC (yyt, Tree_NodeSize [kManifest_array0])
  5043.  yyt->Kind = kManifest_array0;
  5044.  yyt->yyHead.yyMark = 0;
  5045.  return yyt;
  5046. }
  5047.  
  5048. tTree mManifest_array1
  5049. # if defined __STDC__ | defined __cplusplus
  5050. (tTree pExpression, tTree pManifest_array)
  5051. # else
  5052. (pExpression, pManifest_array)
  5053. tTree pExpression;
  5054. tTree pManifest_array;
  5055. # endif
  5056. {
  5057.  register tTree yyt;
  5058.  yyALLOC (yyt, Tree_NodeSize [kManifest_array1])
  5059.  yyt->Kind = kManifest_array1;
  5060.  yyt->yyHead.yyMark = 0;
  5061.  yyt->Manifest_array1.Expression = pExpression;
  5062.  yyt->Manifest_array1.Manifest_array = pManifest_array;
  5063.  return yyt;
  5064. }
  5065.  
  5066. tTree mOld
  5067. # if defined __STDC__ | defined __cplusplus
  5068. (tTree pExpression)
  5069. # else
  5070. (pExpression)
  5071. tTree pExpression;
  5072. # endif
  5073. {
  5074.  register tTree yyt;
  5075.  yyALLOC (yyt, Tree_NodeSize [kOld])
  5076.  yyt->Kind = kOld;
  5077.  yyt->yyHead.yyMark = 0;
  5078.  yyt->Old.Expression = pExpression;
  5079.  return yyt;
  5080. }
  5081.  
  5082. tTree mStrip
  5083. # if defined __STDC__ | defined __cplusplus
  5084. (tTree pList)
  5085. # else
  5086. (pList)
  5087. tTree pList;
  5088. # endif
  5089. {
  5090.  register tTree yyt;
  5091.  yyALLOC (yyt, Tree_NodeSize [kStrip])
  5092.  yyt->Kind = kStrip;
  5093.  yyt->yyHead.yyMark = 0;
  5094.  yyt->Strip.List = pList;
  5095.  return yyt;
  5096. }
  5097.  
  5098. tTree mList
  5099. # if defined __STDC__ | defined __cplusplus
  5100. ()
  5101. # else
  5102. ()
  5103. # endif
  5104. {
  5105.  register tTree yyt;
  5106.  yyALLOC (yyt, Tree_NodeSize [kList])
  5107.  yyt->Kind = kList;
  5108.  yyt->yyHead.yyMark = 0;
  5109.  return yyt;
  5110. }
  5111.  
  5112. tTree mnolist
  5113. # if defined __STDC__ | defined __cplusplus
  5114. ()
  5115. # else
  5116. ()
  5117. # endif
  5118. {
  5119.  register tTree yyt;
  5120.  yyALLOC (yyt, Tree_NodeSize [knolist])
  5121.  yyt->Kind = knolist;
  5122.  yyt->yyHead.yyMark = 0;
  5123.  return yyt;
  5124. }
  5125.  
  5126. tTree mlist
  5127. # if defined __STDC__ | defined __cplusplus
  5128. (tTree pManifest_constant, tTree pList)
  5129. # else
  5130. (pManifest_constant, pList)
  5131. tTree pManifest_constant;
  5132. tTree pList;
  5133. # endif
  5134. {
  5135.  register tTree yyt;
  5136.  yyALLOC (yyt, Tree_NodeSize [klist])
  5137.  yyt->Kind = klist;
  5138.  yyt->yyHead.yyMark = 0;
  5139.  yyt->list.Manifest_constant = pManifest_constant;
  5140.  yyt->list.List = pList;
  5141.  return yyt;
  5142. }
  5143.  
  5144. tTree mManifest_constant
  5145. # if defined __STDC__ | defined __cplusplus
  5146. ()
  5147. # else
  5148. ()
  5149. # endif
  5150. {
  5151.  register tTree yyt;
  5152.  yyALLOC (yyt, Tree_NodeSize [kManifest_constant])
  5153.  yyt->Kind = kManifest_constant;
  5154.  yyt->yyHead.yyMark = 0;
  5155.  return yyt;
  5156. }
  5157.  
  5158. tTree mManifest_constant0
  5159. # if defined __STDC__ | defined __cplusplus
  5160. ()
  5161. # else
  5162. ()
  5163. # endif
  5164. {
  5165.  register tTree yyt;
  5166.  yyALLOC (yyt, Tree_NodeSize [kManifest_constant0])
  5167.  yyt->Kind = kManifest_constant0;
  5168.  yyt->yyHead.yyMark = 0;
  5169.  return yyt;
  5170. }
  5171.  
  5172. tTree mCh
  5173. # if defined __STDC__ | defined __cplusplus
  5174. (int pch, tPosition ppos)
  5175. # else
  5176. (pch, ppos)
  5177. int pch;
  5178. tPosition ppos;
  5179. # endif
  5180. {
  5181.  register tTree yyt;
  5182.  yyALLOC (yyt, Tree_NodeSize [kCh])
  5183.  yyt->Kind = kCh;
  5184.  yyt->yyHead.yyMark = 0;
  5185.  yyt->Ch.ch = pch;
  5186.  yyt->Ch.pos = ppos;
  5187.  return yyt;
  5188. }
  5189.  
  5190. tTree mTrue
  5191. # if defined __STDC__ | defined __cplusplus
  5192. (tPosition ppos)
  5193. # else
  5194. (ppos)
  5195. tPosition ppos;
  5196. # endif
  5197. {
  5198.  register tTree yyt;
  5199.  yyALLOC (yyt, Tree_NodeSize [kTrue])
  5200.  yyt->Kind = kTrue;
  5201.  yyt->yyHead.yyMark = 0;
  5202.  yyt->True.pos = ppos;
  5203.  return yyt;
  5204. }
  5205.  
  5206. tTree mFalse
  5207. # if defined __STDC__ | defined __cplusplus
  5208. (tPosition ppos)
  5209. # else
  5210. (ppos)
  5211. tPosition ppos;
  5212. # endif
  5213. {
  5214.  register tTree yyt;
  5215.  yyALLOC (yyt, Tree_NodeSize [kFalse])
  5216.  yyt->Kind = kFalse;
  5217.  yyt->yyHead.yyMark = 0;
  5218.  yyt->False.pos = ppos;
  5219.  return yyt;
  5220. }
  5221.  
  5222. tTree mInt
  5223. # if defined __STDC__ | defined __cplusplus
  5224. (tTree pSign, long pvalue, tPosition ppos)
  5225. # else
  5226. (pSign, pvalue, ppos)
  5227. tTree pSign;
  5228. long pvalue;
  5229. tPosition ppos;
  5230. # endif
  5231. {
  5232.  register tTree yyt;
  5233.  yyALLOC (yyt, Tree_NodeSize [kInt])
  5234.  yyt->Kind = kInt;
  5235.  yyt->yyHead.yyMark = 0;
  5236.  yyt->Int.Sign = pSign;
  5237.  yyt->Int.value = pvalue;
  5238.  yyt->Int.pos = ppos;
  5239.  return yyt;
  5240. }
  5241.  
  5242. tTree mReal
  5243. # if defined __STDC__ | defined __cplusplus
  5244. (tTree pSign, double pvalue, tPosition ppos)
  5245. # else
  5246. (pSign, pvalue, ppos)
  5247. tTree pSign;
  5248. double pvalue;
  5249. tPosition ppos;
  5250. # endif
  5251. {
  5252.  register tTree yyt;
  5253.  yyALLOC (yyt, Tree_NodeSize [kReal])
  5254.  yyt->Kind = kReal;
  5255.  yyt->yyHead.yyMark = 0;
  5256.  yyt->Real.Sign = pSign;
  5257.  yyt->Real.value = pvalue;
  5258.  yyt->Real.pos = ppos;
  5259.  return yyt;
  5260. }
  5261.  
  5262. tTree m_CHARACTER
  5263. # if defined __STDC__ | defined __cplusplus
  5264. (tPosition ppos)
  5265. # else
  5266. (ppos)
  5267. tPosition ppos;
  5268. # endif
  5269. {
  5270.  register tTree yyt;
  5271.  yyALLOC (yyt, Tree_NodeSize [k_CHARACTER])
  5272.  yyt->Kind = k_CHARACTER;
  5273.  yyt->yyHead.yyMark = 0;
  5274.  yyt->_CHARACTER.pos = ppos;
  5275.  return yyt;
  5276. }
  5277.  
  5278. tTree m_INTEGER
  5279. # if defined __STDC__ | defined __cplusplus
  5280. (tPosition ppos)
  5281. # else
  5282. (ppos)
  5283. tPosition ppos;
  5284. # endif
  5285. {
  5286.  register tTree yyt;
  5287.  yyALLOC (yyt, Tree_NodeSize [k_INTEGER])
  5288.  yyt->Kind = k_INTEGER;
  5289.  yyt->yyHead.yyMark = 0;
  5290.  yyt->_INTEGER.pos = ppos;
  5291.  return yyt;
  5292. }
  5293.  
  5294. tTree m_REAL
  5295. # if defined __STDC__ | defined __cplusplus
  5296. (tPosition ppos)
  5297. # else
  5298. (ppos)
  5299. tPosition ppos;
  5300. # endif
  5301. {
  5302.  register tTree yyt;
  5303.  yyALLOC (yyt, Tree_NodeSize [k_REAL])
  5304.  yyt->Kind = k_REAL;
  5305.  yyt->yyHead.yyMark = 0;
  5306.  yyt->_REAL.pos = ppos;
  5307.  return yyt;
  5308. }
  5309.  
  5310. tTree m_DOUBLE
  5311. # if defined __STDC__ | defined __cplusplus
  5312. (tPosition ppos)
  5313. # else
  5314. (ppos)
  5315. tPosition ppos;
  5316. # endif
  5317. {
  5318.  register tTree yyt;
  5319.  yyALLOC (yyt, Tree_NodeSize [k_DOUBLE])
  5320.  yyt->Kind = k_DOUBLE;
  5321.  yyt->yyHead.yyMark = 0;
  5322.  yyt->_DOUBLE.pos = ppos;
  5323.  return yyt;
  5324. }
  5325.  
  5326. tTree m_BOOLEAN
  5327. # if defined __STDC__ | defined __cplusplus
  5328. (tPosition ppos)
  5329. # else
  5330. (ppos)
  5331. tPosition ppos;
  5332. # endif
  5333. {
  5334.  register tTree yyt;
  5335.  yyALLOC (yyt, Tree_NodeSize [k_BOOLEAN])
  5336.  yyt->Kind = k_BOOLEAN;
  5337.  yyt->yyHead.yyMark = 0;
  5338.  yyt->_BOOLEAN.pos = ppos;
  5339.  return yyt;
  5340. }
  5341.  
  5342. tTree m_STRING
  5343. # if defined __STDC__ | defined __cplusplus
  5344. (tPosition ppos)
  5345. # else
  5346. (ppos)
  5347. tPosition ppos;
  5348. # endif
  5349. {
  5350.  register tTree yyt;
  5351.  yyALLOC (yyt, Tree_NodeSize [k_STRING])
  5352.  yyt->Kind = k_STRING;
  5353.  yyt->yyHead.yyMark = 0;
  5354.  yyt->_STRING.pos = ppos;
  5355.  return yyt;
  5356. }
  5357.  
  5358. tTree m_BIT
  5359. # if defined __STDC__ | defined __cplusplus
  5360. (tPosition ppos)
  5361. # else
  5362. (ppos)
  5363. tPosition ppos;
  5364. # endif
  5365. {
  5366.  register tTree yyt;
  5367.  yyALLOC (yyt, Tree_NodeSize [k_BIT])
  5368.  yyt->Kind = k_BIT;
  5369.  yyt->yyHead.yyMark = 0;
  5370.  yyt->_BIT.pos = ppos;
  5371.  return yyt;
  5372. }
  5373.  
  5374. tTree m_NONE
  5375. # if defined __STDC__ | defined __cplusplus
  5376. (tPosition ppos)
  5377. # else
  5378. (ppos)
  5379. tPosition ppos;
  5380. # endif
  5381. {
  5382.  register tTree yyt;
  5383.  yyALLOC (yyt, Tree_NodeSize [k_NONE])
  5384.  yyt->Kind = k_NONE;
  5385.  yyt->yyHead.yyMark = 0;
  5386.  yyt->_NONE.pos = ppos;
  5387.  return yyt;
  5388. }
  5389.  
  5390. tTree mBitseq
  5391. # if defined __STDC__ | defined __cplusplus
  5392. (tStringRef pliteral, tPosition ppos)
  5393. # else
  5394. (pliteral, ppos)
  5395. tStringRef pliteral;
  5396. tPosition ppos;
  5397. # endif
  5398. {
  5399.  register tTree yyt;
  5400.  yyALLOC (yyt, Tree_NodeSize [kBitseq])
  5401.  yyt->Kind = kBitseq;
  5402.  yyt->yyHead.yyMark = 0;
  5403.  yyt->Bitseq.literal = pliteral;
  5404.  yyt->Bitseq.pos = ppos;
  5405.  return yyt;
  5406. }
  5407.  
  5408. tTree mString
  5409. # if defined __STDC__ | defined __cplusplus
  5410. (tStringRef pstring, tPosition ppos)
  5411. # else
  5412. (pstring, ppos)
  5413. tStringRef pstring;
  5414. tPosition ppos;
  5415. # endif
  5416. {
  5417.  register tTree yyt;
  5418.  yyALLOC (yyt, Tree_NodeSize [kString])
  5419.  yyt->Kind = kString;
  5420.  yyt->yyHead.yyMark = 0;
  5421.  yyt->String.string = pstring;
  5422.  yyt->String.pos = ppos;
  5423.  return yyt;
  5424. }
  5425.  
  5426. tTree mString0
  5427. # if defined __STDC__ | defined __cplusplus
  5428. ()
  5429. # else
  5430. ()
  5431. # endif
  5432. {
  5433.  register tTree yyt;
  5434.  yyALLOC (yyt, Tree_NodeSize [kString0])
  5435.  yyt->Kind = kString0;
  5436.  yyt->yyHead.yyMark = 0;
  5437.  return yyt;
  5438. }
  5439.  
  5440. tTree mEntity
  5441. # if defined __STDC__ | defined __cplusplus
  5442. ()
  5443. # else
  5444. ()
  5445. # endif
  5446. {
  5447.  register tTree yyt;
  5448.  yyALLOC (yyt, Tree_NodeSize [kEntity])
  5449.  yyt->Kind = kEntity;
  5450.  yyt->yyHead.yyMark = 0;
  5451.  return yyt;
  5452. }
  5453.  
  5454. tTree mEntity0
  5455. # if defined __STDC__ | defined __cplusplus
  5456. ()
  5457. # else
  5458. ()
  5459. # endif
  5460. {
  5461.  register tTree yyt;
  5462.  yyALLOC (yyt, Tree_NodeSize [kEntity0])
  5463.  yyt->Kind = kEntity0;
  5464.  yyt->yyHead.yyMark = 0;
  5465.  return yyt;
  5466. }
  5467.  
  5468. tTree mCurrent
  5469. # if defined __STDC__ | defined __cplusplus
  5470. (tPosition ppos)
  5471. # else
  5472. (ppos)
  5473. tPosition ppos;
  5474. # endif
  5475. {
  5476.  register tTree yyt;
  5477.  yyALLOC (yyt, Tree_NodeSize [kCurrent])
  5478.  yyt->Kind = kCurrent;
  5479.  yyt->yyHead.yyMark = 0;
  5480.  yyt->Current.pos = ppos;
  5481.  return yyt;
  5482. }
  5483.  
  5484. tTree mResult
  5485. # if defined __STDC__ | defined __cplusplus
  5486. (tPosition ppos)
  5487. # else
  5488. (ppos)
  5489. tPosition ppos;
  5490. # endif
  5491. {
  5492.  register tTree yyt;
  5493.  yyALLOC (yyt, Tree_NodeSize [kResult])
  5494.  yyt->Kind = kResult;
  5495.  yyt->yyHead.yyMark = 0;
  5496.  yyt->Result.pos = ppos;
  5497.  return yyt;
  5498. }
  5499.  
  5500. tTree mId
  5501. # if defined __STDC__ | defined __cplusplus
  5502. (tIdent pident, tPosition ppos)
  5503. # else
  5504. (pident, ppos)
  5505. tIdent pident;
  5506. tPosition ppos;
  5507. # endif
  5508. {
  5509.  register tTree yyt;
  5510.  yyALLOC (yyt, Tree_NodeSize [kId])
  5511.  yyt->Kind = kId;
  5512.  yyt->yyHead.yyMark = 0;
  5513.  yyt->Id.ident = pident;
  5514.  yyt->Id.pos = ppos;
  5515.  return yyt;
  5516. }
  5517.  
  5518. typedef tTree * yyPtrtTree;
  5519.  
  5520. static FILE * yyf;
  5521.  
  5522. static void yyMark
  5523. # if defined __STDC__ | defined __cplusplus
  5524.  (register tTree yyt)
  5525. # else
  5526.  (yyt) register tTree yyt;
  5527. # endif
  5528. {
  5529.  for (;;) {
  5530.   if (yyt == NoTree || ++ yyt->yyHead.yyMark > 1) return;
  5531.  
  5532.   switch (yyt->Kind) {
  5533. case kEiffel:
  5534. yyt = yyt->Eiffel.Classes; break;
  5535. case kClasses1:
  5536. yyMark (yyt->Classes1.Class_declaration);
  5537. yyt = yyt->Classes1.Classes; break;
  5538. case kClass_declaration:
  5539. yyMark (yyt->Class_declaration.Indexing);
  5540. yyMark (yyt->Class_declaration.Class_header);
  5541. yyMark (yyt->Class_declaration.Formal_generics);
  5542. yyMark (yyt->Class_declaration.Obsolete);
  5543. yyMark (yyt->Class_declaration.Inheritance);
  5544. yyMark (yyt->Class_declaration.Creators);
  5545. yyMark (yyt->Class_declaration.Features);
  5546. yyt = yyt->Class_declaration.Invariant; break;
  5547. case kIndex_list1:
  5548. yyMark (yyt->Index_list1.Index_clause);
  5549. yyt = yyt->Index_list1.Index_list; break;
  5550. case kIndex_clause:
  5551. yyMark (yyt->Index_clause.Index);
  5552. yyt = yyt->Index_clause.Index_terms; break;
  5553. case kClass:
  5554. yyt = yyt->Class.Name; break;
  5555. case kExpanded_class:
  5556. yyt = yyt->Expanded_class.Name; break;
  5557. case kDeferred_class:
  5558. yyt = yyt->Deferred_class.Name; break;
  5559. case kFeatures1:
  5560. yyMark (yyt->Features1.Feature_clause);
  5561. yyt = yyt->Features1.Features; break;
  5562. case kFeature_clause:
  5563. yyMark (yyt->Feature_clause.Clients);
  5564. yyt = yyt->Feature_clause.Feature_decls; break;
  5565. case kClients1:
  5566. yyt = yyt->Clients1.List; break;
  5567. case kFeature_decls1:
  5568. yyMark (yyt->Feature_decls1.Feature_decl);
  5569. yyt = yyt->Feature_decls1.Feature_decls; break;
  5570. case kFeature_decl:
  5571. yyMark (yyt->Feature_decl.New_feature_list);
  5572. yyt = yyt->Feature_decl.Declaration_body; break;
  5573. case kDeclaration_body:
  5574. yyMark (yyt->Declaration_body.Formal_args);
  5575. yyMark (yyt->Declaration_body.Type_mark);
  5576. yyt = yyt->Declaration_body.Const_or_routine; break;
  5577. case kM_const:
  5578. yyt = yyt->M_const.Manifest_constant; break;
  5579. case kRoutine:
  5580. yyMark (yyt->Routine.Obsolete);
  5581. yyMark (yyt->Routine.Precondition);
  5582. yyMark (yyt->Routine.Local_decls);
  5583. yyMark (yyt->Routine.Routine_body);
  5584. yyMark (yyt->Routine.Postcondition);
  5585. yyt = yyt->Routine.Rescue; break;
  5586. case kParent_list1:
  5587. yyMark (yyt->Parent_list1.Parent);
  5588. yyt = yyt->Parent_list1.Parent_list; break;
  5589. case kParent:
  5590. yyMark (yyt->Parent.Class_type);
  5591. yyt = yyt->Parent.Feature_adaptation; break;
  5592. case kFeature_adaptation1:
  5593. yyMark (yyt->Feature_adaptation1.Rename);
  5594. yyMark (yyt->Feature_adaptation1.New_export);
  5595. yyMark (yyt->Feature_adaptation1.Undefine);
  5596. yyMark (yyt->Feature_adaptation1.Redefine);
  5597. yyt = yyt->Feature_adaptation1.Select; break;
  5598. case kRename_list1:
  5599. yyMark (yyt->Rename_list1.Rename_pair);
  5600. yyt = yyt->Rename_list1.Rename_list; break;
  5601. case kRename_pair:
  5602. yyMark (yyt->Rename_pair.Name1);
  5603. yyt = yyt->Rename_pair.Name2; break;
  5604. case kCreators1:
  5605. yyMark (yyt->Creators1.Creation_clause);
  5606. yyt = yyt->Creators1.Creators; break;
  5607. case kCreation_clause:
  5608. yyMark (yyt->Creation_clause.Clients);
  5609. yyt = yyt->Creation_clause.Feature_list; break;
  5610. case kNew_feature_list1:
  5611. yyMark (yyt->New_feature_list1.Feature_name);
  5612. yyt = yyt->New_feature_list1.New_feature_list; break;
  5613. case kFrozen:
  5614. yyt = yyt->Frozen.Feature_name; break;
  5615. case kIdent_name:
  5616. yyt = yyt->Ident_name.Id; break;
  5617. case kPrefix:
  5618. yyt = yyt->Prefix.Op_name; break;
  5619. case kInfix:
  5620. yyt = yyt->Infix.Op_name; break;
  5621. case kNew_export_list1:
  5622. yyMark (yyt->New_export_list1.New_export_item);
  5623. yyt = yyt->New_export_list1.New_export_list; break;
  5624. case kNew_export_item:
  5625. yyMark (yyt->New_export_item.Clients);
  5626. yyt = yyt->New_export_item.Feature_set; break;
  5627. case kFeature_list1:
  5628. yyMark (yyt->Feature_list1.Feature_name);
  5629. yyt = yyt->Feature_list1.Feature_list; break;
  5630. case kFormal_args1:
  5631. yyMark (yyt->Formal_args1.Entity_decl_group);
  5632. yyt = yyt->Formal_args1.Formal_args; break;
  5633. case kDo_body:
  5634. yyt = yyt->Do_body.Compound; break;
  5635. case kOnce_body:
  5636. yyt = yyt->Once_body.Compound; break;
  5637. case kExternal:
  5638. yyMark (yyt->External.Lang1);
  5639. yyt = yyt->External.Lang2; break;
  5640. case kEntity_decl_group:
  5641. yyMark (yyt->Entity_decl_group.Id_list);
  5642. yyt = yyt->Entity_decl_group.Type_mark; break;
  5643. case kFormal_generics1:
  5644. yyMark (yyt->Formal_generics1.Formal_generic);
  5645. yyt = yyt->Formal_generics1.Formal_generics; break;
  5646. case kFormal_generic:
  5647. yyMark (yyt->Formal_generic.Id);
  5648. yyt = yyt->Formal_generic.Constraint; break;
  5649. case kConstraint1:
  5650. yyt = yyt->Constraint1.Class_type; break;
  5651. case kCompound1:
  5652. yyMark (yyt->Compound1.Instruction);
  5653. yyt = yyt->Compound1.Compound; break;
  5654. case kThen_part_list1:
  5655. yyMark (yyt->Then_part_list1.Then_part);
  5656. yyt = yyt->Then_part_list1.Then_part_list; break;
  5657. case kThen_part:
  5658. yyMark (yyt->Then_part.Guard);
  5659. yyt = yyt->Then_part.Compound; break;
  5660. case kWhen_part_list1:
  5661. yyMark (yyt->When_part_list1.When_part);
  5662. yyt = yyt->When_part_list1.When_part_list; break;
  5663. case kWhen_part:
  5664. yyMark (yyt->When_part.Choices);
  5665. yyt = yyt->When_part.Compound; break;
  5666. case kChoices1:
  5667. yyMark (yyt->Choices1.Choice);
  5668. yyt = yyt->Choices1.Choices; break;
  5669. case kInterval:
  5670. yyMark (yyt->Interval.From);
  5671. yyt = yyt->Interval.To; break;
  5672. case kVal:
  5673. yyt = yyt->Val.Manifest_constant; break;
  5674. case kCreation:
  5675. yyMark (yyt->Creation.Type);
  5676. yyMark (yyt->Creation.Entity);
  5677. yyt = yyt->Creation.Unqual_call; break;
  5678. case kCall_instruct:
  5679. yyt = yyt->Call_instruct.Call; break;
  5680. case kAssign:
  5681. yyMark (yyt->Assign.Addr);
  5682. yyt = yyt->Assign.Expression; break;
  5683. case kRev_assign:
  5684. yyMark (yyt->Rev_assign.Addr);
  5685. yyt = yyt->Rev_assign.Expression; break;
  5686. case kConditional:
  5687. yyMark (yyt->Conditional.Then_part);
  5688. yyt = yyt->Conditional.Else_part; break;
  5689. case kMulti_branch:
  5690. yyMark (yyt->Multi_branch.Guard);
  5691. yyMark (yyt->Multi_branch.When_part_list);
  5692. yyt = yyt->Multi_branch.Else_part; break;
  5693. case kLoop:
  5694. yyMark (yyt->Loop.Initialization);
  5695. yyMark (yyt->Loop.Invariant);
  5696. yyMark (yyt->Loop.Variant);
  5697. yyt = yyt->Loop.Loop_body; break;
  5698. case kCheck:
  5699. yyt = yyt->Check.Assertion; break;
  5700. case kDebug:
  5701. yyMark (yyt->Debug.Debug_keys);
  5702. yyt = yyt->Debug.Compound; break;
  5703. case kLoop_body1:
  5704. yyMark (yyt->Loop_body1.Exit);
  5705. yyt = yyt->Loop_body1.Compound; break;
  5706. case kClass_type:
  5707. yyMark (yyt->Class_type.Id);
  5708. yyt = yyt->Class_type.Actual_generics; break;
  5709. case kClass_type_expanded:
  5710. yyMark (yyt->Class_type_expanded.Id);
  5711. yyt = yyt->Class_type_expanded.Actual_generics; break;
  5712. case kBit_type:
  5713. yyt = yyt->Bit_type.Manifest_constant; break;
  5714. case kSimple_type:
  5715. yyt = yyt->Simple_type.Manifest_constant; break;
  5716. case kAnchored:
  5717. yyt = yyt->Anchored.Entity; break;
  5718. case kActual_generics1:
  5719. yyt = yyt->Actual_generics1.Type_list; break;
  5720. case kCondition1:
  5721. yyt = yyt->Condition1.Assertion; break;
  5722. case kAssertion1:
  5723. yyMark (yyt->Assertion1.Assertion_clause);
  5724. yyt = yyt->Assertion1.Assertion; break;
  5725. case kAssertion_clause1:
  5726. yyMark (yyt->Assertion_clause1.Tag);
  5727. yyt = yyt->Assertion_clause1.Expression; break;
  5728. case kType_list1:
  5729. yyMark (yyt->Type_list1.Type);
  5730. yyt = yyt->Type_list1.Type_list; break;
  5731. case kCall_chain1:
  5732. yyMark (yyt->Call_chain1.Unqual_call);
  5733. yyt = yyt->Call_chain1.Call_chain; break;
  5734. case kUnqual_call1:
  5735. yyMark (yyt->Unqual_call1.Entity);
  5736. yyt = yyt->Unqual_call1.Actuals; break;
  5737. case kActuals1:
  5738. yyt = yyt->Actuals1.Actual_list; break;
  5739. case kActual_list1:
  5740. yyMark (yyt->Actual_list1.Actual);
  5741. yyt = yyt->Actual_list1.Actual_list; break;
  5742. case kAddr:
  5743. yyt = yyt->Addr.Entity; break;
  5744. case kSimple_expr:
  5745. yyt = yyt->Simple_expr.Manifest_constant; break;
  5746. case kCall:
  5747. yyMark (yyt->Call.Qual);
  5748. yyt = yyt->Call.Call_chain; break;
  5749. case kBin_expr:
  5750. yyMark (yyt->Bin_expr.Lop);
  5751. yyMark (yyt->Bin_expr.Op);
  5752. yyt = yyt->Bin_expr.Rop; break;
  5753. case kUn_expr:
  5754. yyMark (yyt->Un_expr.Op);
  5755. yyt = yyt->Un_expr.Expression; break;
  5756. case kParenth:
  5757. yyt = yyt->Parenth.Expression; break;
  5758. case kManifest_array1:
  5759. yyMark (yyt->Manifest_array1.Expression);
  5760. yyt = yyt->Manifest_array1.Manifest_array; break;
  5761. case kOld:
  5762. yyt = yyt->Old.Expression; break;
  5763. case kStrip:
  5764. yyt = yyt->Strip.List; break;
  5765. case klist:
  5766. yyMark (yyt->list.Manifest_constant);
  5767. yyt = yyt->list.List; break;
  5768. case kInt:
  5769. yyt = yyt->Int.Sign; break;
  5770. case kReal:
  5771. yyt = yyt->Real.Sign; break;
  5772.   default: return;
  5773.   }
  5774.  }
  5775. }
  5776.  
  5777. # define yyInitTreeStoreSize 32
  5778. # define yyMapToTree(yyLabel) yyTreeStorePtr [yyLabel]
  5779.  
  5780. static unsigned long yyTreeStoreSize = yyInitTreeStoreSize;
  5781. static tTree yyTreeStore [yyInitTreeStoreSize];
  5782. static tTree * yyTreeStorePtr = yyTreeStore;
  5783. static int yyLabelCount;
  5784. static short yyRecursionLevel = 0;
  5785.  
  5786. static Tree_tLabel yyMapToLabel
  5787. # if defined __STDC__ | defined __cplusplus
  5788.  (tTree yyt)
  5789. # else
  5790.  (yyt) tTree yyt;
  5791. # endif
  5792. {
  5793.  register int yyi;
  5794.  for (yyi = 1; yyi <= yyLabelCount; yyi ++) if (yyTreeStorePtr [yyi] == yyt) return yyi;
  5795.  if (++ yyLabelCount == yyTreeStoreSize)
  5796.   ExtendArray ((char * *) & yyTreeStorePtr, & yyTreeStoreSize, sizeof (tTree));
  5797.  yyTreeStorePtr [yyLabelCount] = yyt;
  5798.  return yyLabelCount;
  5799. }
  5800.  
  5801. static void yyWriteTree ();
  5802.  
  5803. static void yyWriteNl () { (void) putc ('\n', yyf); }
  5804.  
  5805. static void yyWriteSelector
  5806. # if defined __STDC__ | defined __cplusplus
  5807.  (char * yys)
  5808. # else
  5809.  (yys) char * yys;
  5810. # endif
  5811. {
  5812.  register int yyi = 16 - strlen (yys);
  5813.  (void) fputs (yys, yyf);
  5814.  while (yyi -- > 0) (void) putc (' ', yyf);
  5815.  (void) fputs (" = ", yyf);
  5816. }
  5817.  
  5818. static void yyWriteHex
  5819. # if defined __STDC__ | defined __cplusplus
  5820.  (unsigned char * yyx, int yysize)
  5821. # else
  5822.  (yyx, yysize) unsigned char * yyx; int yysize;
  5823. # endif
  5824. { register int yyi; for (yyi = 0; yyi < yysize; yyi ++) (void) fprintf (yyf, "%02x ", yyx [yyi]); }
  5825.  
  5826. static void yyWriteAdr
  5827. # if defined __STDC__ | defined __cplusplus
  5828.  (tTree yyt)
  5829. # else
  5830.  (yyt) tTree yyt;
  5831. # endif
  5832. {
  5833.  if (yyt == NoTree) (void) fputs ("NoTree", yyf);
  5834.  else yyWriteHex ((unsigned char *) & yyt, sizeof (yyt));
  5835.  yyWriteNl ();
  5836. }
  5837.  
  5838. static void yWriteNodeEiffel
  5839. # if defined __STDC__ | defined __cplusplus
  5840.  (tTree yyt)
  5841. # else
  5842.  (yyt) tTree yyt;
  5843. # endif
  5844. {
  5845.  yyWriteSelector ("Classes"); yyWriteAdr (yyt->Eiffel.Classes);
  5846. }
  5847.  
  5848. static void yWriteNodeClasses1
  5849. # if defined __STDC__ | defined __cplusplus
  5850.  (tTree yyt)
  5851. # else
  5852.  (yyt) tTree yyt;
  5853. # endif
  5854. {
  5855.  yyWriteSelector ("Class_declaration"); yyWriteAdr (yyt->Classes1.Class_declaration);
  5856.  yyWriteSelector ("Classes"); yyWriteAdr (yyt->Classes1.Classes);
  5857. }
  5858.  
  5859. static void yWriteNodeClass_declaration
  5860. # if defined __STDC__ | defined __cplusplus
  5861.  (tTree yyt)
  5862. # else
  5863.  (yyt) tTree yyt;
  5864. # endif
  5865. {
  5866.  yyWriteSelector ("Indexing"); yyWriteAdr (yyt->Class_declaration.Indexing);
  5867.  yyWriteSelector ("Class_header"); yyWriteAdr (yyt->Class_declaration.Class_header);
  5868.  yyWriteSelector ("Formal_generics"); yyWriteAdr (yyt->Class_declaration.Formal_generics);
  5869.  yyWriteSelector ("Obsolete"); yyWriteAdr (yyt->Class_declaration.Obsolete);
  5870.  yyWriteSelector ("Inheritance"); yyWriteAdr (yyt->Class_declaration.Inheritance);
  5871.  yyWriteSelector ("Creators"); yyWriteAdr (yyt->Class_declaration.Creators);
  5872.  yyWriteSelector ("Features"); yyWriteAdr (yyt->Class_declaration.Features);
  5873.  yyWriteSelector ("Invariant"); yyWriteAdr (yyt->Class_declaration.Invariant);
  5874.  yyWriteSelector ("comment"); writetStringRef (yyt->Class_declaration.comment) yyWriteNl ();
  5875. }
  5876.  
  5877. static void yWriteNodeIndex_list1
  5878. # if defined __STDC__ | defined __cplusplus
  5879.  (tTree yyt)
  5880. # else
  5881.  (yyt) tTree yyt;
  5882. # endif
  5883. {
  5884.  yyWriteSelector ("Index_clause"); yyWriteAdr (yyt->Index_list1.Index_clause);
  5885.  yyWriteSelector ("Index_list"); yyWriteAdr (yyt->Index_list1.Index_list);
  5886. }
  5887.  
  5888. static void yWriteNodeIndex_clause
  5889. # if defined __STDC__ | defined __cplusplus
  5890.  (tTree yyt)
  5891. # else
  5892.  (yyt) tTree yyt;
  5893. # endif
  5894. {
  5895.  yyWriteSelector ("Index"); yyWriteAdr (yyt->Index_clause.Index);
  5896.  yyWriteSelector ("Index_terms"); yyWriteAdr (yyt->Index_clause.Index_terms);
  5897. }
  5898.  
  5899. static void yWriteNodeClass
  5900. # if defined __STDC__ | defined __cplusplus
  5901.  (tTree yyt)
  5902. # else
  5903.  (yyt) tTree yyt;
  5904. # endif
  5905. {
  5906.  yyWriteSelector ("Name"); yyWriteAdr (yyt->Class.Name);
  5907. }
  5908.  
  5909. static void yWriteNodeExpanded_class
  5910. # if defined __STDC__ | defined __cplusplus
  5911.  (tTree yyt)
  5912. # else
  5913.  (yyt) tTree yyt;
  5914. # endif
  5915. {
  5916.  yyWriteSelector ("Name"); yyWriteAdr (yyt->Expanded_class.Name);
  5917. }
  5918.  
  5919. static void yWriteNodeDeferred_class
  5920. # if defined __STDC__ | defined __cplusplus
  5921.  (tTree yyt)
  5922. # else
  5923.  (yyt) tTree yyt;
  5924. # endif
  5925. {
  5926.  yyWriteSelector ("Name"); yyWriteAdr (yyt->Deferred_class.Name);
  5927. }
  5928.  
  5929. static void yWriteNodeFeatures1
  5930. # if defined __STDC__ | defined __cplusplus
  5931.  (tTree yyt)
  5932. # else
  5933.  (yyt) tTree yyt;
  5934. # endif
  5935. {
  5936.  yyWriteSelector ("Feature_clause"); yyWriteAdr (yyt->Features1.Feature_clause);
  5937.  yyWriteSelector ("Features"); yyWriteAdr (yyt->Features1.Features);
  5938. }
  5939.  
  5940. static void yWriteNodeFeature_clause
  5941. # if defined __STDC__ | defined __cplusplus
  5942.  (tTree yyt)
  5943. # else
  5944.  (yyt) tTree yyt;
  5945. # endif
  5946. {
  5947.  yyWriteSelector ("Clients"); yyWriteAdr (yyt->Feature_clause.Clients);
  5948.  yyWriteSelector ("comment"); writetStringRef (yyt->Feature_clause.comment) yyWriteNl ();
  5949.  yyWriteSelector ("Feature_decls"); yyWriteAdr (yyt->Feature_clause.Feature_decls);
  5950. }
  5951.  
  5952. static void yWriteNodeClients1
  5953. # if defined __STDC__ | defined __cplusplus
  5954.  (tTree yyt)
  5955. # else
  5956.  (yyt) tTree yyt;
  5957. # endif
  5958. {
  5959.  yyWriteSelector ("List"); yyWriteAdr (yyt->Clients1.List);
  5960. }
  5961.  
  5962. static void yWriteNodeFeature_decls1
  5963. # if defined __STDC__ | defined __cplusplus
  5964.  (tTree yyt)
  5965. # else
  5966.  (yyt) tTree yyt;
  5967. # endif
  5968. {
  5969.  yyWriteSelector ("Feature_decl"); yyWriteAdr (yyt->Feature_decls1.Feature_decl);
  5970.  yyWriteSelector ("Feature_decls"); yyWriteAdr (yyt->Feature_decls1.Feature_decls);
  5971. }
  5972.  
  5973. static void yWriteNodeFeature_decl
  5974. # if defined __STDC__ | defined __cplusplus
  5975.  (tTree yyt)
  5976. # else
  5977.  (yyt) tTree yyt;
  5978. # endif
  5979. {
  5980.  yyWriteSelector ("New_feature_list"); yyWriteAdr (yyt->Feature_decl.New_feature_list);
  5981.  yyWriteSelector ("Declaration_body"); yyWriteAdr (yyt->Feature_decl.Declaration_body);
  5982. }
  5983.  
  5984. static void yWriteNodeDeclaration_body
  5985. # if defined __STDC__ | defined __cplusplus
  5986.  (tTree yyt)
  5987. # else
  5988.  (yyt) tTree yyt;
  5989. # endif
  5990. {
  5991.  yyWriteSelector ("Formal_args"); yyWriteAdr (yyt->Declaration_body.Formal_args);
  5992.  yyWriteSelector ("Type_mark"); yyWriteAdr (yyt->Declaration_body.Type_mark);
  5993.  yyWriteSelector ("Const_or_routine"); yyWriteAdr (yyt->Declaration_body.Const_or_routine);
  5994. }
  5995.  
  5996. static void yWriteNodeM_const
  5997. # if defined __STDC__ | defined __cplusplus
  5998.  (tTree yyt)
  5999. # else
  6000.  (yyt) tTree yyt;
  6001. # endif
  6002. {
  6003.  yyWriteSelector ("Manifest_constant"); yyWriteAdr (yyt->M_const.Manifest_constant);
  6004. }
  6005.  
  6006. static void yWriteNodeUnique
  6007. # if defined __STDC__ | defined __cplusplus
  6008.  (tTree yyt)
  6009. # else
  6010.  (yyt) tTree yyt;
  6011. # endif
  6012. {
  6013.  yyWriteSelector ("pos"); writetPosition (yyt->Unique.pos) yyWriteNl ();
  6014. }
  6015.  
  6016. static void yWriteNodeRoutine
  6017. # if defined __STDC__ | defined __cplusplus
  6018.  (tTree yyt)
  6019. # else
  6020.  (yyt) tTree yyt;
  6021. # endif
  6022. {
  6023.  yyWriteSelector ("Obsolete"); yyWriteAdr (yyt->Routine.Obsolete);
  6024.  yyWriteSelector ("comment"); writetStringRef (yyt->Routine.comment) yyWriteNl ();
  6025.  yyWriteSelector ("Precondition"); yyWriteAdr (yyt->Routine.Precondition);
  6026.  yyWriteSelector ("Local_decls"); yyWriteAdr (yyt->Routine.Local_decls);
  6027.  yyWriteSelector ("Routine_body"); yyWriteAdr (yyt->Routine.Routine_body);
  6028.  yyWriteSelector ("Postcondition"); yyWriteAdr (yyt->Routine.Postcondition);
  6029.  yyWriteSelector ("Rescue"); yyWriteAdr (yyt->Routine.Rescue);
  6030.  yyWriteSelector ("end_comment"); writetStringRef (yyt->Routine.end_comment) yyWriteNl ();
  6031. }
  6032.  
  6033. static void yWriteNodeParent_list1
  6034. # if defined __STDC__ | defined __cplusplus
  6035.  (tTree yyt)
  6036. # else
  6037.  (yyt) tTree yyt;
  6038. # endif
  6039. {
  6040.  yyWriteSelector ("Parent"); yyWriteAdr (yyt->Parent_list1.Parent);
  6041.  yyWriteSelector ("Parent_list"); yyWriteAdr (yyt->Parent_list1.Parent_list);
  6042. }
  6043.  
  6044. static void yWriteNodeParent
  6045. # if defined __STDC__ | defined __cplusplus
  6046.  (tTree yyt)
  6047. # else
  6048.  (yyt) tTree yyt;
  6049. # endif
  6050. {
  6051.  yyWriteSelector ("Class_type"); yyWriteAdr (yyt->Parent.Class_type);
  6052.  yyWriteSelector ("Feature_adaptation"); yyWriteAdr (yyt->Parent.Feature_adaptation);
  6053. }
  6054.  
  6055. static void yWriteNodeFeature_adaptation1
  6056. # if defined __STDC__ | defined __cplusplus
  6057.  (tTree yyt)
  6058. # else
  6059.  (yyt) tTree yyt;
  6060. # endif
  6061. {
  6062.  yyWriteSelector ("Rename"); yyWriteAdr (yyt->Feature_adaptation1.Rename);
  6063.  yyWriteSelector ("New_export"); yyWriteAdr (yyt->Feature_adaptation1.New_export);
  6064.  yyWriteSelector ("Undefine"); yyWriteAdr (yyt->Feature_adaptation1.Undefine);
  6065.  yyWriteSelector ("Redefine"); yyWriteAdr (yyt->Feature_adaptation1.Redefine);
  6066.  yyWriteSelector ("Select"); yyWriteAdr (yyt->Feature_adaptation1.Select);
  6067. }
  6068.  
  6069. static void yWriteNodeRename_list1
  6070. # if defined __STDC__ | defined __cplusplus
  6071.  (tTree yyt)
  6072. # else
  6073.  (yyt) tTree yyt;
  6074. # endif
  6075. {
  6076.  yyWriteSelector ("Rename_pair"); yyWriteAdr (yyt->Rename_list1.Rename_pair);
  6077.  yyWriteSelector ("Rename_list"); yyWriteAdr (yyt->Rename_list1.Rename_list);
  6078. }
  6079.  
  6080. static void yWriteNodeRename_pair
  6081. # if defined __STDC__ | defined __cplusplus
  6082.  (tTree yyt)
  6083. # else
  6084.  (yyt) tTree yyt;
  6085. # endif
  6086. {
  6087.  yyWriteSelector ("Name1"); yyWriteAdr (yyt->Rename_pair.Name1);
  6088.  yyWriteSelector ("Name2"); yyWriteAdr (yyt->Rename_pair.Name2);
  6089. }
  6090.  
  6091. static void yWriteNodeCreators1
  6092. # if defined __STDC__ | defined __cplusplus
  6093.  (tTree yyt)
  6094. # else
  6095.  (yyt) tTree yyt;
  6096. # endif
  6097. {
  6098.  yyWriteSelector ("Creation_clause"); yyWriteAdr (yyt->Creators1.Creation_clause);
  6099.  yyWriteSelector ("Creators"); yyWriteAdr (yyt->Creators1.Creators);
  6100. }
  6101.  
  6102. static void yWriteNodeCreation_clause
  6103. # if defined __STDC__ | defined __cplusplus
  6104.  (tTree yyt)
  6105. # else
  6106.  (yyt) tTree yyt;
  6107. # endif
  6108. {
  6109.  yyWriteSelector ("Clients"); yyWriteAdr (yyt->Creation_clause.Clients);
  6110.  yyWriteSelector ("comment"); writetStringRef (yyt->Creation_clause.comment) yyWriteNl ();
  6111.  yyWriteSelector ("Feature_list"); yyWriteAdr (yyt->Creation_clause.Feature_list);
  6112. }
  6113.  
  6114. static void yWriteNodeNew_feature_list1
  6115. # if defined __STDC__ | defined __cplusplus
  6116.  (tTree yyt)
  6117. # else
  6118.  (yyt) tTree yyt;
  6119. # endif
  6120. {
  6121.  yyWriteSelector ("Feature_name"); yyWriteAdr (yyt->New_feature_list1.Feature_name);
  6122.  yyWriteSelector ("New_feature_list"); yyWriteAdr (yyt->New_feature_list1.New_feature_list);
  6123. }
  6124.  
  6125. static void yWriteNodeFrozen
  6126. # if defined __STDC__ | defined __cplusplus
  6127.  (tTree yyt)
  6128. # else
  6129.  (yyt) tTree yyt;
  6130. # endif
  6131. {
  6132.  yyWriteSelector ("Feature_name"); yyWriteAdr (yyt->Frozen.Feature_name);
  6133. }
  6134.  
  6135. static void yWriteNodeIdent_name
  6136. # if defined __STDC__ | defined __cplusplus
  6137.  (tTree yyt)
  6138. # else
  6139.  (yyt) tTree yyt;
  6140. # endif
  6141. {
  6142.  yyWriteSelector ("Id"); yyWriteAdr (yyt->Ident_name.Id);
  6143. }
  6144.  
  6145. static void yWriteNodePrefix
  6146. # if defined __STDC__ | defined __cplusplus
  6147.  (tTree yyt)
  6148. # else
  6149.  (yyt) tTree yyt;
  6150. # endif
  6151. {
  6152.  yyWriteSelector ("Op_name"); yyWriteAdr (yyt->Prefix.Op_name);
  6153. }
  6154.  
  6155. static void yWriteNodeInfix
  6156. # if defined __STDC__ | defined __cplusplus
  6157.  (tTree yyt)
  6158. # else
  6159.  (yyt) tTree yyt;
  6160. # endif
  6161. {
  6162.  yyWriteSelector ("Op_name"); yyWriteAdr (yyt->Infix.Op_name);
  6163. }
  6164.  
  6165. static void yWriteNodeOp_name
  6166. # if defined __STDC__ | defined __cplusplus
  6167.  (tTree yyt)
  6168. # else
  6169.  (yyt) tTree yyt;
  6170. # endif
  6171. {
  6172.  yyWriteSelector ("pos"); writetPosition (yyt->Op_name.pos) yyWriteNl ();
  6173. }
  6174.  
  6175. static void yWriteNodeFree_op
  6176. # if defined __STDC__ | defined __cplusplus
  6177.  (tTree yyt)
  6178. # else
  6179.  (yyt) tTree yyt;
  6180. # endif
  6181. {
  6182.  yWriteNodeOp_name (yyt); 
  6183.  yyWriteSelector ("ident"); writetIdent (yyt->Free_op.ident) yyWriteNl ();
  6184. }
  6185.  
  6186. static void yWriteNodeOper
  6187. # if defined __STDC__ | defined __cplusplus
  6188.  (tTree yyt)
  6189. # else
  6190.  (yyt) tTree yyt;
  6191. # endif
  6192. {
  6193.  yWriteNodeOp_name (yyt); 
  6194.  yyWriteSelector ("op"); writeint (yyt->Oper.op) yyWriteNl ();
  6195. }
  6196.  
  6197. static void yWriteNodeNew_export_list1
  6198. # if defined __STDC__ | defined __cplusplus
  6199.  (tTree yyt)
  6200. # else
  6201.  (yyt) tTree yyt;
  6202. # endif
  6203. {
  6204.  yyWriteSelector ("New_export_item"); yyWriteAdr (yyt->New_export_list1.New_export_item);
  6205.  yyWriteSelector ("New_export_list"); yyWriteAdr (yyt->New_export_list1.New_export_list);
  6206. }
  6207.  
  6208. static void yWriteNodeNew_export_item
  6209. # if defined __STDC__ | defined __cplusplus
  6210.  (tTree yyt)
  6211. # else
  6212.  (yyt) tTree yyt;
  6213. # endif
  6214. {
  6215.  yyWriteSelector ("Clients"); yyWriteAdr (yyt->New_export_item.Clients);
  6216.  yyWriteSelector ("Feature_set"); yyWriteAdr (yyt->New_export_item.Feature_set);
  6217. }
  6218.  
  6219. static void yWriteNodeFeature_list1
  6220. # if defined __STDC__ | defined __cplusplus
  6221.  (tTree yyt)
  6222. # else
  6223.  (yyt) tTree yyt;
  6224. # endif
  6225. {
  6226.  yyWriteSelector ("Feature_name"); yyWriteAdr (yyt->Feature_list1.Feature_name);
  6227.  yyWriteSelector ("Feature_list"); yyWriteAdr (yyt->Feature_list1.Feature_list);
  6228. }
  6229.  
  6230. static void yWriteNodeFormal_args1
  6231. # if defined __STDC__ | defined __cplusplus
  6232.  (tTree yyt)
  6233. # else
  6234.  (yyt) tTree yyt;
  6235. # endif
  6236. {
  6237.  yyWriteSelector ("Entity_decl_group"); yyWriteAdr (yyt->Formal_args1.Entity_decl_group);
  6238.  yyWriteSelector ("Formal_args"); yyWriteAdr (yyt->Formal_args1.Formal_args);
  6239. }
  6240.  
  6241. static void yWriteNodeDo_body
  6242. # if defined __STDC__ | defined __cplusplus
  6243.  (tTree yyt)
  6244. # else
  6245.  (yyt) tTree yyt;
  6246. # endif
  6247. {
  6248.  yyWriteSelector ("Compound"); yyWriteAdr (yyt->Do_body.Compound);
  6249. }
  6250.  
  6251. static void yWriteNodeOnce_body
  6252. # if defined __STDC__ | defined __cplusplus
  6253.  (tTree yyt)
  6254. # else
  6255.  (yyt) tTree yyt;
  6256. # endif
  6257. {
  6258.  yyWriteSelector ("Compound"); yyWriteAdr (yyt->Once_body.Compound);
  6259. }
  6260.  
  6261. static void yWriteNodeExternal
  6262. # if defined __STDC__ | defined __cplusplus
  6263.  (tTree yyt)
  6264. # else
  6265.  (yyt) tTree yyt;
  6266. # endif
  6267. {
  6268.  yyWriteSelector ("Lang1"); yyWriteAdr (yyt->External.Lang1);
  6269.  yyWriteSelector ("Lang2"); yyWriteAdr (yyt->External.Lang2);
  6270. }
  6271.  
  6272. static void yWriteNodeDeferred
  6273. # if defined __STDC__ | defined __cplusplus
  6274.  (tTree yyt)
  6275. # else
  6276.  (yyt) tTree yyt;
  6277. # endif
  6278. {
  6279.  yyWriteSelector ("pos"); writetPosition (yyt->Deferred.pos) yyWriteNl ();
  6280. }
  6281.  
  6282. static void yWriteNodeEntity_decl_group
  6283. # if defined __STDC__ | defined __cplusplus
  6284.  (tTree yyt)
  6285. # else
  6286.  (yyt) tTree yyt;
  6287. # endif
  6288. {
  6289.  yyWriteSelector ("Id_list"); yyWriteAdr (yyt->Entity_decl_group.Id_list);
  6290.  yyWriteSelector ("Type_mark"); yyWriteAdr (yyt->Entity_decl_group.Type_mark);
  6291. }
  6292.  
  6293. static void yWriteNodeFormal_generics1
  6294. # if defined __STDC__ | defined __cplusplus
  6295.  (tTree yyt)
  6296. # else
  6297.  (yyt) tTree yyt;
  6298. # endif
  6299. {
  6300.  yyWriteSelector ("Formal_generic"); yyWriteAdr (yyt->Formal_generics1.Formal_generic);
  6301.  yyWriteSelector ("Formal_generics"); yyWriteAdr (yyt->Formal_generics1.Formal_generics);
  6302. }
  6303.  
  6304. static void yWriteNodeFormal_generic
  6305. # if defined __STDC__ | defined __cplusplus
  6306.  (tTree yyt)
  6307. # else
  6308.  (yyt) tTree yyt;
  6309. # endif
  6310. {
  6311.  yyWriteSelector ("Id"); yyWriteAdr (yyt->Formal_generic.Id);
  6312.  yyWriteSelector ("Constraint"); yyWriteAdr (yyt->Formal_generic.Constraint);
  6313. }
  6314.  
  6315. static void yWriteNodeConstraint1
  6316. # if defined __STDC__ | defined __cplusplus
  6317.  (tTree yyt)
  6318. # else
  6319.  (yyt) tTree yyt;
  6320. # endif
  6321. {
  6322.  yyWriteSelector ("Class_type"); yyWriteAdr (yyt->Constraint1.Class_type);
  6323. }
  6324.  
  6325. static void yWriteNodeCompound1
  6326. # if defined __STDC__ | defined __cplusplus
  6327.  (tTree yyt)
  6328. # else
  6329.  (yyt) tTree yyt;
  6330. # endif
  6331. {
  6332.  yyWriteSelector ("Instruction"); yyWriteAdr (yyt->Compound1.Instruction);
  6333.  yyWriteSelector ("Compound"); yyWriteAdr (yyt->Compound1.Compound);
  6334. }
  6335.  
  6336. static void yWriteNodeThen_part_list1
  6337. # if defined __STDC__ | defined __cplusplus
  6338.  (tTree yyt)
  6339. # else
  6340.  (yyt) tTree yyt;
  6341. # endif
  6342. {
  6343.  yyWriteSelector ("Then_part"); yyWriteAdr (yyt->Then_part_list1.Then_part);
  6344.  yyWriteSelector ("Then_part_list"); yyWriteAdr (yyt->Then_part_list1.Then_part_list);
  6345. }
  6346.  
  6347. static void yWriteNodeThen_part
  6348. # if defined __STDC__ | defined __cplusplus
  6349.  (tTree yyt)
  6350. # else
  6351.  (yyt) tTree yyt;
  6352. # endif
  6353. {
  6354.  yyWriteSelector ("Guard"); yyWriteAdr (yyt->Then_part.Guard);
  6355.  yyWriteSelector ("Compound"); yyWriteAdr (yyt->Then_part.Compound);
  6356. }
  6357.  
  6358. static void yWriteNodeWhen_part_list1
  6359. # if defined __STDC__ | defined __cplusplus
  6360.  (tTree yyt)
  6361. # else
  6362.  (yyt) tTree yyt;
  6363. # endif
  6364. {
  6365.  yyWriteSelector ("When_part"); yyWriteAdr (yyt->When_part_list1.When_part);
  6366.  yyWriteSelector ("When_part_list"); yyWriteAdr (yyt->When_part_list1.When_part_list);
  6367. }
  6368.  
  6369. static void yWriteNodeWhen_part
  6370. # if defined __STDC__ | defined __cplusplus
  6371.  (tTree yyt)
  6372. # else
  6373.  (yyt) tTree yyt;
  6374. # endif
  6375. {
  6376.  yyWriteSelector ("Choices"); yyWriteAdr (yyt->When_part.Choices);
  6377.  yyWriteSelector ("Compound"); yyWriteAdr (yyt->When_part.Compound);
  6378. }
  6379.  
  6380. static void yWriteNodeChoices1
  6381. # if defined __STDC__ | defined __cplusplus
  6382.  (tTree yyt)
  6383. # else
  6384.  (yyt) tTree yyt;
  6385. # endif
  6386. {
  6387.  yyWriteSelector ("Choice"); yyWriteAdr (yyt->Choices1.Choice);
  6388.  yyWriteSelector ("Choices"); yyWriteAdr (yyt->Choices1.Choices);
  6389. }
  6390.  
  6391. static void yWriteNodeInterval
  6392. # if defined __STDC__ | defined __cplusplus
  6393.  (tTree yyt)
  6394. # else
  6395.  (yyt) tTree yyt;
  6396. # endif
  6397. {
  6398.  yyWriteSelector ("From"); yyWriteAdr (yyt->Interval.From);
  6399.  yyWriteSelector ("To"); yyWriteAdr (yyt->Interval.To);
  6400. }
  6401.  
  6402. static void yWriteNodeVal
  6403. # if defined __STDC__ | defined __cplusplus
  6404.  (tTree yyt)
  6405. # else
  6406.  (yyt) tTree yyt;
  6407. # endif
  6408. {
  6409.  yyWriteSelector ("Manifest_constant"); yyWriteAdr (yyt->Val.Manifest_constant);
  6410. }
  6411.  
  6412. static void yWriteNodeCreation
  6413. # if defined __STDC__ | defined __cplusplus
  6414.  (tTree yyt)
  6415. # else
  6416.  (yyt) tTree yyt;
  6417. # endif
  6418. {
  6419.  yyWriteSelector ("Type"); yyWriteAdr (yyt->Creation.Type);
  6420.  yyWriteSelector ("Entity"); yyWriteAdr (yyt->Creation.Entity);
  6421.  yyWriteSelector ("Unqual_call"); yyWriteAdr (yyt->Creation.Unqual_call);
  6422. }
  6423.  
  6424. static void yWriteNodeCall_instruct
  6425. # if defined __STDC__ | defined __cplusplus
  6426.  (tTree yyt)
  6427. # else
  6428.  (yyt) tTree yyt;
  6429. # endif
  6430. {
  6431.  yyWriteSelector ("Call"); yyWriteAdr (yyt->Call_instruct.Call);
  6432. }
  6433.  
  6434. static void yWriteNodeAssign
  6435. # if defined __STDC__ | defined __cplusplus
  6436.  (tTree yyt)
  6437. # else
  6438.  (yyt) tTree yyt;
  6439. # endif
  6440. {
  6441.  yyWriteSelector ("Addr"); yyWriteAdr (yyt->Assign.Addr);
  6442.  yyWriteSelector ("Expression"); yyWriteAdr (yyt->Assign.Expression);
  6443. }
  6444.  
  6445. static void yWriteNodeRev_assign
  6446. # if defined __STDC__ | defined __cplusplus
  6447.  (tTree yyt)
  6448. # else
  6449.  (yyt) tTree yyt;
  6450. # endif
  6451. {
  6452.  yyWriteSelector ("Addr"); yyWriteAdr (yyt->Rev_assign.Addr);
  6453.  yyWriteSelector ("Expression"); yyWriteAdr (yyt->Rev_assign.Expression);
  6454. }
  6455.  
  6456. static void yWriteNodeConditional
  6457. # if defined __STDC__ | defined __cplusplus
  6458.  (tTree yyt)
  6459. # else
  6460.  (yyt) tTree yyt;
  6461. # endif
  6462. {
  6463.  yyWriteSelector ("Then_part"); yyWriteAdr (yyt->Conditional.Then_part);
  6464.  yyWriteSelector ("Else_part"); yyWriteAdr (yyt->Conditional.Else_part);
  6465. }
  6466.  
  6467. static void yWriteNodeMulti_branch
  6468. # if defined __STDC__ | defined __cplusplus
  6469.  (tTree yyt)
  6470. # else
  6471.  (yyt) tTree yyt;
  6472. # endif
  6473. {
  6474.  yyWriteSelector ("Guard"); yyWriteAdr (yyt->Multi_branch.Guard);
  6475.  yyWriteSelector ("When_part_list"); yyWriteAdr (yyt->Multi_branch.When_part_list);
  6476.  yyWriteSelector ("Else_part"); yyWriteAdr (yyt->Multi_branch.Else_part);
  6477. }
  6478.  
  6479. static void yWriteNodeLoop
  6480. # if defined __STDC__ | defined __cplusplus
  6481.  (tTree yyt)
  6482. # else
  6483.  (yyt) tTree yyt;
  6484. # endif
  6485. {
  6486.  yyWriteSelector ("Initialization"); yyWriteAdr (yyt->Loop.Initialization);
  6487.  yyWriteSelector ("Invariant"); yyWriteAdr (yyt->Loop.Invariant);
  6488.  yyWriteSelector ("Variant"); yyWriteAdr (yyt->Loop.Variant);
  6489.  yyWriteSelector ("Loop_body"); yyWriteAdr (yyt->Loop.Loop_body);
  6490. }
  6491.  
  6492. static void yWriteNodeCheck
  6493. # if defined __STDC__ | defined __cplusplus
  6494.  (tTree yyt)
  6495. # else
  6496.  (yyt) tTree yyt;
  6497. # endif
  6498. {
  6499.  yyWriteSelector ("Assertion"); yyWriteAdr (yyt->Check.Assertion);
  6500. }
  6501.  
  6502. static void yWriteNodeDebug
  6503. # if defined __STDC__ | defined __cplusplus
  6504.  (tTree yyt)
  6505. # else
  6506.  (yyt) tTree yyt;
  6507. # endif
  6508. {
  6509.  yyWriteSelector ("Debug_keys"); yyWriteAdr (yyt->Debug.Debug_keys);
  6510.  yyWriteSelector ("Compound"); yyWriteAdr (yyt->Debug.Compound);
  6511. }
  6512.  
  6513. static void yWriteNodeRetry
  6514. # if defined __STDC__ | defined __cplusplus
  6515.  (tTree yyt)
  6516. # else
  6517.  (yyt) tTree yyt;
  6518. # endif
  6519. {
  6520.  yyWriteSelector ("pos"); writetPosition (yyt->Retry.pos) yyWriteNl ();
  6521. }
  6522.  
  6523. static void yWriteNodeLoop_body1
  6524. # if defined __STDC__ | defined __cplusplus
  6525.  (tTree yyt)
  6526. # else
  6527.  (yyt) tTree yyt;
  6528. # endif
  6529. {
  6530.  yyWriteSelector ("Exit"); yyWriteAdr (yyt->Loop_body1.Exit);
  6531.  yyWriteSelector ("Compound"); yyWriteAdr (yyt->Loop_body1.Compound);
  6532. }
  6533.  
  6534. static void yWriteNodeClass_type
  6535. # if defined __STDC__ | defined __cplusplus
  6536.  (tTree yyt)
  6537. # else
  6538.  (yyt) tTree yyt;
  6539. # endif
  6540. {
  6541.  yyWriteSelector ("Id"); yyWriteAdr (yyt->Class_type.Id);
  6542.  yyWriteSelector ("Actual_generics"); yyWriteAdr (yyt->Class_type.Actual_generics);
  6543. }
  6544.  
  6545. static void yWriteNodeClass_type_expanded
  6546. # if defined __STDC__ | defined __cplusplus
  6547.  (tTree yyt)
  6548. # else
  6549.  (yyt) tTree yyt;
  6550. # endif
  6551. {
  6552.  yyWriteSelector ("Id"); yyWriteAdr (yyt->Class_type_expanded.Id);
  6553.  yyWriteSelector ("Actual_generics"); yyWriteAdr (yyt->Class_type_expanded.Actual_generics);
  6554. }
  6555.  
  6556. static void yWriteNodeBit_type
  6557. # if defined __STDC__ | defined __cplusplus
  6558.  (tTree yyt)
  6559. # else
  6560.  (yyt) tTree yyt;
  6561. # endif
  6562. {
  6563.  yyWriteSelector ("Manifest_constant"); yyWriteAdr (yyt->Bit_type.Manifest_constant);
  6564. }
  6565.  
  6566. static void yWriteNodeSimple_type
  6567. # if defined __STDC__ | defined __cplusplus
  6568.  (tTree yyt)
  6569. # else
  6570.  (yyt) tTree yyt;
  6571. # endif
  6572. {
  6573.  yyWriteSelector ("Manifest_constant"); yyWriteAdr (yyt->Simple_type.Manifest_constant);
  6574. }
  6575.  
  6576. static void yWriteNodeAnchored
  6577. # if defined __STDC__ | defined __cplusplus
  6578.  (tTree yyt)
  6579. # else
  6580.  (yyt) tTree yyt;
  6581. # endif
  6582. {
  6583.  yyWriteSelector ("Entity"); yyWriteAdr (yyt->Anchored.Entity);
  6584. }
  6585.  
  6586. static void yWriteNodeActual_generics1
  6587. # if defined __STDC__ | defined __cplusplus
  6588.  (tTree yyt)
  6589. # else
  6590.  (yyt) tTree yyt;
  6591. # endif
  6592. {
  6593.  yyWriteSelector ("Type_list"); yyWriteAdr (yyt->Actual_generics1.Type_list);
  6594. }
  6595.  
  6596. static void yWriteNodeCondition1
  6597. # if defined __STDC__ | defined __cplusplus
  6598.  (tTree yyt)
  6599. # else
  6600.  (yyt) tTree yyt;
  6601. # endif
  6602. {
  6603.  yyWriteSelector ("extension"); writeint (yyt->Condition1.extension) yyWriteNl ();
  6604.  yyWriteSelector ("Assertion"); yyWriteAdr (yyt->Condition1.Assertion);
  6605. }
  6606.  
  6607. static void yWriteNodeAssertion1
  6608. # if defined __STDC__ | defined __cplusplus
  6609.  (tTree yyt)
  6610. # else
  6611.  (yyt) tTree yyt;
  6612. # endif
  6613. {
  6614.  yyWriteSelector ("Assertion_clause"); yyWriteAdr (yyt->Assertion1.Assertion_clause);
  6615.  yyWriteSelector ("Assertion"); yyWriteAdr (yyt->Assertion1.Assertion);
  6616. }
  6617.  
  6618. static void yWriteNodeAssertion_clause1
  6619. # if defined __STDC__ | defined __cplusplus
  6620.  (tTree yyt)
  6621. # else
  6622.  (yyt) tTree yyt;
  6623. # endif
  6624. {
  6625.  yyWriteSelector ("Tag"); yyWriteAdr (yyt->Assertion_clause1.Tag);
  6626.  yyWriteSelector ("Expression"); yyWriteAdr (yyt->Assertion_clause1.Expression);
  6627. }
  6628.  
  6629. static void yWriteNodeType_list1
  6630. # if defined __STDC__ | defined __cplusplus
  6631.  (tTree yyt)
  6632. # else
  6633.  (yyt) tTree yyt;
  6634. # endif
  6635. {
  6636.  yyWriteSelector ("Type"); yyWriteAdr (yyt->Type_list1.Type);
  6637.  yyWriteSelector ("Type_list"); yyWriteAdr (yyt->Type_list1.Type_list);
  6638. }
  6639.  
  6640. static void yWriteNodeCall_chain1
  6641. # if defined __STDC__ | defined __cplusplus
  6642.  (tTree yyt)
  6643. # else
  6644.  (yyt) tTree yyt;
  6645. # endif
  6646. {
  6647.  yyWriteSelector ("Unqual_call"); yyWriteAdr (yyt->Call_chain1.Unqual_call);
  6648.  yyWriteSelector ("Call_chain"); yyWriteAdr (yyt->Call_chain1.Call_chain);
  6649. }
  6650.  
  6651. static void yWriteNodeUnqual_call1
  6652. # if defined __STDC__ | defined __cplusplus
  6653.  (tTree yyt)
  6654. # else
  6655.  (yyt) tTree yyt;
  6656. # endif
  6657. {
  6658.  yyWriteSelector ("Entity"); yyWriteAdr (yyt->Unqual_call1.Entity);
  6659.  yyWriteSelector ("Actuals"); yyWriteAdr (yyt->Unqual_call1.Actuals);
  6660. }
  6661.  
  6662. static void yWriteNodeActuals1
  6663. # if defined __STDC__ | defined __cplusplus
  6664.  (tTree yyt)
  6665. # else
  6666.  (yyt) tTree yyt;
  6667. # endif
  6668. {
  6669.  yyWriteSelector ("Actual_list"); yyWriteAdr (yyt->Actuals1.Actual_list);
  6670. }
  6671.  
  6672. static void yWriteNodeActual_list1
  6673. # if defined __STDC__ | defined __cplusplus
  6674.  (tTree yyt)
  6675. # else
  6676.  (yyt) tTree yyt;
  6677. # endif
  6678. {
  6679.  yyWriteSelector ("Actual"); yyWriteAdr (yyt->Actual_list1.Actual);
  6680.  yyWriteSelector ("Actual_list"); yyWriteAdr (yyt->Actual_list1.Actual_list);
  6681. }
  6682.  
  6683. static void yWriteNodeAddr
  6684. # if defined __STDC__ | defined __cplusplus
  6685.  (tTree yyt)
  6686. # else
  6687.  (yyt) tTree yyt;
  6688. # endif
  6689. {
  6690.  yyWriteSelector ("Entity"); yyWriteAdr (yyt->Addr.Entity);
  6691. }
  6692.  
  6693. static void yWriteNodeComment
  6694. # if defined __STDC__ | defined __cplusplus
  6695.  (tTree yyt)
  6696. # else
  6697.  (yyt) tTree yyt;
  6698. # endif
  6699. {
  6700.  yyWriteSelector ("comment"); writetStringRef (yyt->Comment.comment) yyWriteNl ();
  6701. }
  6702.  
  6703. static void yWriteNodeSimple_expr
  6704. # if defined __STDC__ | defined __cplusplus
  6705.  (tTree yyt)
  6706. # else
  6707.  (yyt) tTree yyt;
  6708. # endif
  6709. {
  6710.  yyWriteSelector ("Manifest_constant"); yyWriteAdr (yyt->Simple_expr.Manifest_constant);
  6711. }
  6712.  
  6713. static void yWriteNodeCall
  6714. # if defined __STDC__ | defined __cplusplus
  6715.  (tTree yyt)
  6716. # else
  6717.  (yyt) tTree yyt;
  6718. # endif
  6719. {
  6720.  yyWriteSelector ("Qual"); yyWriteAdr (yyt->Call.Qual);
  6721.  yyWriteSelector ("Call_chain"); yyWriteAdr (yyt->Call.Call_chain);
  6722. }
  6723.  
  6724. static void yWriteNodeBin_expr
  6725. # if defined __STDC__ | defined __cplusplus
  6726.  (tTree yyt)
  6727. # else
  6728.  (yyt) tTree yyt;
  6729. # endif
  6730. {
  6731.  yyWriteSelector ("Lop"); yyWriteAdr (yyt->Bin_expr.Lop);
  6732.  yyWriteSelector ("Op"); yyWriteAdr (yyt->Bin_expr.Op);
  6733.  yyWriteSelector ("Rop"); yyWriteAdr (yyt->Bin_expr.Rop);
  6734. }
  6735.  
  6736. static void yWriteNodeUn_expr
  6737. # if defined __STDC__ | defined __cplusplus
  6738.  (tTree yyt)
  6739. # else
  6740.  (yyt) tTree yyt;
  6741. # endif
  6742. {
  6743.  yyWriteSelector ("Op"); yyWriteAdr (yyt->Un_expr.Op);
  6744.  yyWriteSelector ("Expression"); yyWriteAdr (yyt->Un_expr.Expression);
  6745. }
  6746.  
  6747. static void yWriteNodeParenth
  6748. # if defined __STDC__ | defined __cplusplus
  6749.  (tTree yyt)
  6750. # else
  6751.  (yyt) tTree yyt;
  6752. # endif
  6753. {
  6754.  yyWriteSelector ("Expression"); yyWriteAdr (yyt->Parenth.Expression);
  6755. }
  6756.  
  6757. static void yWriteNodeManifest_array1
  6758. # if defined __STDC__ | defined __cplusplus
  6759.  (tTree yyt)
  6760. # else
  6761.  (yyt) tTree yyt;
  6762. # endif
  6763. {
  6764.  yyWriteSelector ("Expression"); yyWriteAdr (yyt->Manifest_array1.Expression);
  6765.  yyWriteSelector ("Manifest_array"); yyWriteAdr (yyt->Manifest_array1.Manifest_array);
  6766. }
  6767.  
  6768. static void yWriteNodeOld
  6769. # if defined __STDC__ | defined __cplusplus
  6770.  (tTree yyt)
  6771. # else
  6772.  (yyt) tTree yyt;
  6773. # endif
  6774. {
  6775.  yyWriteSelector ("Expression"); yyWriteAdr (yyt->Old.Expression);
  6776. }
  6777.  
  6778. static void yWriteNodeStrip
  6779. # if defined __STDC__ | defined __cplusplus
  6780.  (tTree yyt)
  6781. # else
  6782.  (yyt) tTree yyt;
  6783. # endif
  6784. {
  6785.  yyWriteSelector ("List"); yyWriteAdr (yyt->Strip.List);
  6786. }
  6787.  
  6788. static void yWriteNodelist
  6789. # if defined __STDC__ | defined __cplusplus
  6790.  (tTree yyt)
  6791. # else
  6792.  (yyt) tTree yyt;
  6793. # endif
  6794. {
  6795.  yyWriteSelector ("Manifest_constant"); yyWriteAdr (yyt->list.Manifest_constant);
  6796.  yyWriteSelector ("List"); yyWriteAdr (yyt->list.List);
  6797. }
  6798.  
  6799. static void yWriteNodeCh
  6800. # if defined __STDC__ | defined __cplusplus
  6801.  (tTree yyt)
  6802. # else
  6803.  (yyt) tTree yyt;
  6804. # endif
  6805. {
  6806.  yyWriteSelector ("ch"); writeint (yyt->Ch.ch) yyWriteNl ();
  6807.  yyWriteSelector ("pos"); writetPosition (yyt->Ch.pos) yyWriteNl ();
  6808. }
  6809.  
  6810. static void yWriteNodeTrue
  6811. # if defined __STDC__ | defined __cplusplus
  6812.  (tTree yyt)
  6813. # else
  6814.  (yyt) tTree yyt;
  6815. # endif
  6816. {
  6817.  yyWriteSelector ("pos"); writetPosition (yyt->True.pos) yyWriteNl ();
  6818. }
  6819.  
  6820. static void yWriteNodeFalse
  6821. # if defined __STDC__ | defined __cplusplus
  6822.  (tTree yyt)
  6823. # else
  6824.  (yyt) tTree yyt;
  6825. # endif
  6826. {
  6827.  yyWriteSelector ("pos"); writetPosition (yyt->False.pos) yyWriteNl ();
  6828. }
  6829.  
  6830. static void yWriteNodeInt
  6831. # if defined __STDC__ | defined __cplusplus
  6832.  (tTree yyt)
  6833. # else
  6834.  (yyt) tTree yyt;
  6835. # endif
  6836. {
  6837.  yyWriteSelector ("Sign"); yyWriteAdr (yyt->Int.Sign);
  6838.  yyWriteSelector ("value"); writelong (yyt->Int.value) yyWriteNl ();
  6839.  yyWriteSelector ("pos"); writetPosition (yyt->Int.pos) yyWriteNl ();
  6840. }
  6841.  
  6842. static void yWriteNodeReal
  6843. # if defined __STDC__ | defined __cplusplus
  6844.  (tTree yyt)
  6845. # else
  6846.  (yyt) tTree yyt;
  6847. # endif
  6848. {
  6849.  yyWriteSelector ("Sign"); yyWriteAdr (yyt->Real.Sign);
  6850.  yyWriteSelector ("value"); writedouble (yyt->Real.value) yyWriteNl ();
  6851.  yyWriteSelector ("pos"); writetPosition (yyt->Real.pos) yyWriteNl ();
  6852. }
  6853.  
  6854. static void yWriteNode_CHARACTER
  6855. # if defined __STDC__ | defined __cplusplus
  6856.  (tTree yyt)
  6857. # else
  6858.  (yyt) tTree yyt;
  6859. # endif
  6860. {
  6861.  yyWriteSelector ("pos"); writetPosition (yyt->_CHARACTER.pos) yyWriteNl ();
  6862. }
  6863.  
  6864. static void yWriteNode_INTEGER
  6865. # if defined __STDC__ | defined __cplusplus
  6866.  (tTree yyt)
  6867. # else
  6868.  (yyt) tTree yyt;
  6869. # endif
  6870. {
  6871.  yyWriteSelector ("pos"); writetPosition (yyt->_INTEGER.pos) yyWriteNl ();
  6872. }
  6873.  
  6874. static void yWriteNode_REAL
  6875. # if defined __STDC__ | defined __cplusplus
  6876.  (tTree yyt)
  6877. # else
  6878.  (yyt) tTree yyt;
  6879. # endif
  6880. {
  6881.  yyWriteSelector ("pos"); writetPosition (yyt->_REAL.pos) yyWriteNl ();
  6882. }
  6883.  
  6884. static void yWriteNode_DOUBLE
  6885. # if defined __STDC__ | defined __cplusplus
  6886.  (tTree yyt)
  6887. # else
  6888.  (yyt) tTree yyt;
  6889. # endif
  6890. {
  6891.  yyWriteSelector ("pos"); writetPosition (yyt->_DOUBLE.pos) yyWriteNl ();
  6892. }
  6893.  
  6894. static void yWriteNode_BOOLEAN
  6895. # if defined __STDC__ | defined __cplusplus
  6896.  (tTree yyt)
  6897. # else
  6898.  (yyt) tTree yyt;
  6899. # endif
  6900. {
  6901.  yyWriteSelector ("pos"); writetPosition (yyt->_BOOLEAN.pos) yyWriteNl ();
  6902. }
  6903.  
  6904. static void yWriteNode_STRING
  6905. # if defined __STDC__ | defined __cplusplus
  6906.  (tTree yyt)
  6907. # else
  6908.  (yyt) tTree yyt;
  6909. # endif
  6910. {
  6911.  yyWriteSelector ("pos"); writetPosition (yyt->_STRING.pos) yyWriteNl ();
  6912. }
  6913.  
  6914. static void yWriteNode_BIT
  6915. # if defined __STDC__ | defined __cplusplus
  6916.  (tTree yyt)
  6917. # else
  6918.  (yyt) tTree yyt;
  6919. # endif
  6920. {
  6921.  yyWriteSelector ("pos"); writetPosition (yyt->_BIT.pos) yyWriteNl ();
  6922. }
  6923.  
  6924. static void yWriteNode_NONE
  6925. # if defined __STDC__ | defined __cplusplus
  6926.  (tTree yyt)
  6927. # else
  6928.  (yyt) tTree yyt;
  6929. # endif
  6930. {
  6931.  yyWriteSelector ("pos"); writetPosition (yyt->_NONE.pos) yyWriteNl ();
  6932. }
  6933.  
  6934. static void yWriteNodeBitseq
  6935. # if defined __STDC__ | defined __cplusplus
  6936.  (tTree yyt)
  6937. # else
  6938.  (yyt) tTree yyt;
  6939. # endif
  6940. {
  6941.  yyWriteSelector ("literal"); writetStringRef (yyt->Bitseq.literal) yyWriteNl ();
  6942.  yyWriteSelector ("pos"); writetPosition (yyt->Bitseq.pos) yyWriteNl ();
  6943. }
  6944.  
  6945. static void yWriteNodeString
  6946. # if defined __STDC__ | defined __cplusplus
  6947.  (tTree yyt)
  6948. # else
  6949.  (yyt) tTree yyt;
  6950. # endif
  6951. {
  6952.  yyWriteSelector ("string"); writetStringRef (yyt->String.string) yyWriteNl ();
  6953.  yyWriteSelector ("pos"); writetPosition (yyt->String.pos) yyWriteNl ();
  6954. }
  6955.  
  6956. static void yWriteNodeCurrent
  6957. # if defined __STDC__ | defined __cplusplus
  6958.  (tTree yyt)
  6959. # else
  6960.  (yyt) tTree yyt;
  6961. # endif
  6962. {
  6963.  yyWriteSelector ("pos"); writetPosition (yyt->Current.pos) yyWriteNl ();
  6964. }
  6965.  
  6966. static void yWriteNodeResult
  6967. # if defined __STDC__ | defined __cplusplus
  6968.  (tTree yyt)
  6969. # else
  6970.  (yyt) tTree yyt;
  6971. # endif
  6972. {
  6973.  yyWriteSelector ("pos"); writetPosition (yyt->Result.pos) yyWriteNl ();
  6974. }
  6975.  
  6976. static void yWriteNodeId
  6977. # if defined __STDC__ | defined __cplusplus
  6978.  (tTree yyt)
  6979. # else
  6980.  (yyt) tTree yyt;
  6981. # endif
  6982. {
  6983.  yyWriteSelector ("ident"); writetIdent (yyt->Id.ident) yyWriteNl ();
  6984.  yyWriteSelector ("pos"); writetPosition (yyt->Id.pos) yyWriteNl ();
  6985. }
  6986.  
  6987. void WriteTreeNode
  6988. # if defined __STDC__ | defined __cplusplus
  6989.  (FILE * yyyf, tTree yyt)
  6990. # else
  6991.  (yyyf, yyt) FILE * yyyf; tTree yyt;
  6992. # endif
  6993. {
  6994.  yyf = yyyf;
  6995.  if (yyt == NoTree) { (void) fputs ("NoTree\n", yyf); return; }
  6996.  
  6997.  switch (yyt->Kind) {
  6998. case kEiffel: (void) fputs (Tree_NodeName [kEiffel], yyf); (void) fputc ('\n', yyf);
  6999.  yWriteNodeEiffel (yyt); break;
  7000. case kClasses: (void) fputs (Tree_NodeName [kClasses], yyf); (void) fputc ('\n', yyf);
  7001.  break;
  7002. case kClasses0: (void) fputs (Tree_NodeName [kClasses0], yyf); (void) fputc ('\n', yyf);
  7003.  break;
  7004. case kClasses1: (void) fputs (Tree_NodeName [kClasses1], yyf); (void) fputc ('\n', yyf);
  7005.  yWriteNodeClasses1 (yyt); break;
  7006. case kClass_declaration: (void) fputs (Tree_NodeName [kClass_declaration], yyf); (void) fputc ('\n', yyf);
  7007.  yWriteNodeClass_declaration (yyt); break;
  7008. case kIndex_list: (void) fputs (Tree_NodeName [kIndex_list], yyf); (void) fputc ('\n', yyf);
  7009.  break;
  7010. case kIndex_list0: (void) fputs (Tree_NodeName [kIndex_list0], yyf); (void) fputc ('\n', yyf);
  7011.  break;
  7012. case kIndex_list1: (void) fputs (Tree_NodeName [kIndex_list1], yyf); (void) fputc ('\n', yyf);
  7013.  yWriteNodeIndex_list1 (yyt); break;
  7014. case kIndex_clause: (void) fputs (Tree_NodeName [kIndex_clause], yyf); (void) fputc ('\n', yyf);
  7015.  yWriteNodeIndex_clause (yyt); break;
  7016. case kClass_header: (void) fputs (Tree_NodeName [kClass_header], yyf); (void) fputc ('\n', yyf);
  7017.  break;
  7018. case kClass_header0: (void) fputs (Tree_NodeName [kClass_header0], yyf); (void) fputc ('\n', yyf);
  7019.  break;
  7020. case kClass: (void) fputs (Tree_NodeName [kClass], yyf); (void) fputc ('\n', yyf);
  7021.  yWriteNodeClass (yyt); break;
  7022. case kExpanded_class: (void) fputs (Tree_NodeName [kExpanded_class], yyf); (void) fputc ('\n', yyf);
  7023.  yWriteNodeExpanded_class (yyt); break;
  7024. case kDeferred_class: (void) fputs (Tree_NodeName [kDeferred_class], yyf); (void) fputc ('\n', yyf);
  7025.  yWriteNodeDeferred_class (yyt); break;
  7026. case kFeatures: (void) fputs (Tree_NodeName [kFeatures], yyf); (void) fputc ('\n', yyf);
  7027.  break;
  7028. case kFeatures0: (void) fputs (Tree_NodeName [kFeatures0], yyf); (void) fputc ('\n', yyf);
  7029.  break;
  7030. case kFeatures1: (void) fputs (Tree_NodeName [kFeatures1], yyf); (void) fputc ('\n', yyf);
  7031.  yWriteNodeFeatures1 (yyt); break;
  7032. case kFeature_clause: (void) fputs (Tree_NodeName [kFeature_clause], yyf); (void) fputc ('\n', yyf);
  7033.  yWriteNodeFeature_clause (yyt); break;
  7034. case kClients: (void) fputs (Tree_NodeName [kClients], yyf); (void) fputc ('\n', yyf);
  7035.  break;
  7036. case kClients0: (void) fputs (Tree_NodeName [kClients0], yyf); (void) fputc ('\n', yyf);
  7037.  break;
  7038. case kClients1: (void) fputs (Tree_NodeName [kClients1], yyf); (void) fputc ('\n', yyf);
  7039.  yWriteNodeClients1 (yyt); break;
  7040. case kFeature_decls: (void) fputs (Tree_NodeName [kFeature_decls], yyf); (void) fputc ('\n', yyf);
  7041.  break;
  7042. case kFeature_decls0: (void) fputs (Tree_NodeName [kFeature_decls0], yyf); (void) fputc ('\n', yyf);
  7043.  break;
  7044. case kFeature_decls1: (void) fputs (Tree_NodeName [kFeature_decls1], yyf); (void) fputc ('\n', yyf);
  7045.  yWriteNodeFeature_decls1 (yyt); break;
  7046. case kFeature_decl: (void) fputs (Tree_NodeName [kFeature_decl], yyf); (void) fputc ('\n', yyf);
  7047.  yWriteNodeFeature_decl (yyt); break;
  7048. case kDeclaration_body: (void) fputs (Tree_NodeName [kDeclaration_body], yyf); (void) fputc ('\n', yyf);
  7049.  yWriteNodeDeclaration_body (yyt); break;
  7050. case kConst_or_routine: (void) fputs (Tree_NodeName [kConst_or_routine], yyf); (void) fputc ('\n', yyf);
  7051.  break;
  7052. case kConst_or_routine0: (void) fputs (Tree_NodeName [kConst_or_routine0], yyf); (void) fputc ('\n', yyf);
  7053.  break;
  7054. case kM_const: (void) fputs (Tree_NodeName [kM_const], yyf); (void) fputc ('\n', yyf);
  7055.  yWriteNodeM_const (yyt); break;
  7056. case kUnique: (void) fputs (Tree_NodeName [kUnique], yyf); (void) fputc ('\n', yyf);
  7057.  yWriteNodeUnique (yyt); break;
  7058. case kRoutine: (void) fputs (Tree_NodeName [kRoutine], yyf); (void) fputc ('\n', yyf);
  7059.  yWriteNodeRoutine (yyt); break;
  7060. case kParent_list: (void) fputs (Tree_NodeName [kParent_list], yyf); (void) fputc ('\n', yyf);
  7061.  break;
  7062. case kParent_list0: (void) fputs (Tree_NodeName [kParent_list0], yyf); (void) fputc ('\n', yyf);
  7063.  break;
  7064. case kParent_list1: (void) fputs (Tree_NodeName [kParent_list1], yyf); (void) fputc ('\n', yyf);
  7065.  yWriteNodeParent_list1 (yyt); break;
  7066. case kParent: (void) fputs (Tree_NodeName [kParent], yyf); (void) fputc ('\n', yyf);
  7067.  yWriteNodeParent (yyt); break;
  7068. case kFeature_adaptation: (void) fputs (Tree_NodeName [kFeature_adaptation], yyf); (void) fputc ('\n', yyf);
  7069.  break;
  7070. case kFeature_adaptation0: (void) fputs (Tree_NodeName [kFeature_adaptation0], yyf); (void) fputc ('\n', yyf);
  7071.  break;
  7072. case kFeature_adaptation1: (void) fputs (Tree_NodeName [kFeature_adaptation1], yyf); (void) fputc ('\n', yyf);
  7073.  yWriteNodeFeature_adaptation1 (yyt); break;
  7074. case kRename_list: (void) fputs (Tree_NodeName [kRename_list], yyf); (void) fputc ('\n', yyf);
  7075.  break;
  7076. case kRename_list0: (void) fputs (Tree_NodeName [kRename_list0], yyf); (void) fputc ('\n', yyf);
  7077.  break;
  7078. case kRename_list1: (void) fputs (Tree_NodeName [kRename_list1], yyf); (void) fputc ('\n', yyf);
  7079.  yWriteNodeRename_list1 (yyt); break;
  7080. case kRename_pair: (void) fputs (Tree_NodeName [kRename_pair], yyf); (void) fputc ('\n', yyf);
  7081.  yWriteNodeRename_pair (yyt); break;
  7082. case kCreators: (void) fputs (Tree_NodeName [kCreators], yyf); (void) fputc ('\n', yyf);
  7083.  break;
  7084. case kCreators0: (void) fputs (Tree_NodeName [kCreators0], yyf); (void) fputc ('\n', yyf);
  7085.  break;
  7086. case kCreators1: (void) fputs (Tree_NodeName [kCreators1], yyf); (void) fputc ('\n', yyf);
  7087.  yWriteNodeCreators1 (yyt); break;
  7088. case kCreation_clause: (void) fputs (Tree_NodeName [kCreation_clause], yyf); (void) fputc ('\n', yyf);
  7089.  yWriteNodeCreation_clause (yyt); break;
  7090. case kNew_feature_list: (void) fputs (Tree_NodeName [kNew_feature_list], yyf); (void) fputc ('\n', yyf);
  7091.  break;
  7092. case kNew_feature_list0: (void) fputs (Tree_NodeName [kNew_feature_list0], yyf); (void) fputc ('\n', yyf);
  7093.  break;
  7094. case kNew_feature_list1: (void) fputs (Tree_NodeName [kNew_feature_list1], yyf); (void) fputc ('\n', yyf);
  7095.  yWriteNodeNew_feature_list1 (yyt); break;
  7096. case kFeature_name: (void) fputs (Tree_NodeName [kFeature_name], yyf); (void) fputc ('\n', yyf);
  7097.  break;
  7098. case kFrozen: (void) fputs (Tree_NodeName [kFrozen], yyf); (void) fputc ('\n', yyf);
  7099.  yWriteNodeFrozen (yyt); break;
  7100. case kIdent_name: (void) fputs (Tree_NodeName [kIdent_name], yyf); (void) fputc ('\n', yyf);
  7101.  yWriteNodeIdent_name (yyt); break;
  7102. case kOp: (void) fputs (Tree_NodeName [kOp], yyf); (void) fputc ('\n', yyf);
  7103.  break;
  7104. case kPrefix: (void) fputs (Tree_NodeName [kPrefix], yyf); (void) fputc ('\n', yyf);
  7105.  yWriteNodePrefix (yyt); break;
  7106. case kInfix: (void) fputs (Tree_NodeName [kInfix], yyf); (void) fputc ('\n', yyf);
  7107.  yWriteNodeInfix (yyt); break;
  7108. case kOp_name: (void) fputs (Tree_NodeName [kOp_name], yyf); (void) fputc ('\n', yyf);
  7109.  yWriteNodeOp_name (yyt); break;
  7110. case kFree_op: (void) fputs (Tree_NodeName [kFree_op], yyf); (void) fputc ('\n', yyf);
  7111.  yWriteNodeFree_op (yyt); break;
  7112. case kOper: (void) fputs (Tree_NodeName [kOper], yyf); (void) fputc ('\n', yyf);
  7113.  yWriteNodeOper (yyt); break;
  7114. case kNew_export_list: (void) fputs (Tree_NodeName [kNew_export_list], yyf); (void) fputc ('\n', yyf);
  7115.  break;
  7116. case kNew_export_list0: (void) fputs (Tree_NodeName [kNew_export_list0], yyf); (void) fputc ('\n', yyf);
  7117.  break;
  7118. case kNew_export_list1: (void) fputs (Tree_NodeName [kNew_export_list1], yyf); (void) fputc ('\n', yyf);
  7119.  yWriteNodeNew_export_list1 (yyt); break;
  7120. case kNew_export_item: (void) fputs (Tree_NodeName [kNew_export_item], yyf); (void) fputc ('\n', yyf);
  7121.  yWriteNodeNew_export_item (yyt); break;
  7122. case kFeature_list: (void) fputs (Tree_NodeName [kFeature_list], yyf); (void) fputc ('\n', yyf);
  7123.  break;
  7124. case kAll: (void) fputs (Tree_NodeName [kAll], yyf); (void) fputc ('\n', yyf);
  7125.  break;
  7126. case kFeature_list0: (void) fputs (Tree_NodeName [kFeature_list0], yyf); (void) fputc ('\n', yyf);
  7127.  break;
  7128. case kFeature_list1: (void) fputs (Tree_NodeName [kFeature_list1], yyf); (void) fputc ('\n', yyf);
  7129.  yWriteNodeFeature_list1 (yyt); break;
  7130. case kFormal_args: (void) fputs (Tree_NodeName [kFormal_args], yyf); (void) fputc ('\n', yyf);
  7131.  break;
  7132. case kFormal_args0: (void) fputs (Tree_NodeName [kFormal_args0], yyf); (void) fputc ('\n', yyf);
  7133.  break;
  7134. case kFormal_args1: (void) fputs (Tree_NodeName [kFormal_args1], yyf); (void) fputc ('\n', yyf);
  7135.  yWriteNodeFormal_args1 (yyt); break;
  7136. case kRoutine_body: (void) fputs (Tree_NodeName [kRoutine_body], yyf); (void) fputc ('\n', yyf);
  7137.  break;
  7138. case kRoutine_body0: (void) fputs (Tree_NodeName [kRoutine_body0], yyf); (void) fputc ('\n', yyf);
  7139.  break;
  7140. case kEffective: (void) fputs (Tree_NodeName [kEffective], yyf); (void) fputc ('\n', yyf);
  7141.  break;
  7142. case kInternal: (void) fputs (Tree_NodeName [kInternal], yyf); (void) fputc ('\n', yyf);
  7143.  break;
  7144. case kDo_body: (void) fputs (Tree_NodeName [kDo_body], yyf); (void) fputc ('\n', yyf);
  7145.  yWriteNodeDo_body (yyt); break;
  7146. case kOnce_body: (void) fputs (Tree_NodeName [kOnce_body], yyf); (void) fputc ('\n', yyf);
  7147.  yWriteNodeOnce_body (yyt); break;
  7148. case kExternal: (void) fputs (Tree_NodeName [kExternal], yyf); (void) fputc ('\n', yyf);
  7149.  yWriteNodeExternal (yyt); break;
  7150. case kDeferred: (void) fputs (Tree_NodeName [kDeferred], yyf); (void) fputc ('\n', yyf);
  7151.  yWriteNodeDeferred (yyt); break;
  7152. case kEntity_decl_group: (void) fputs (Tree_NodeName [kEntity_decl_group], yyf); (void) fputc ('\n', yyf);
  7153.  yWriteNodeEntity_decl_group (yyt); break;
  7154. case kFormal_generics: (void) fputs (Tree_NodeName [kFormal_generics], yyf); (void) fputc ('\n', yyf);
  7155.  break;
  7156. case kFormal_generics0: (void) fputs (Tree_NodeName [kFormal_generics0], yyf); (void) fputc ('\n', yyf);
  7157.  break;
  7158. case kFormal_generics1: (void) fputs (Tree_NodeName [kFormal_generics1], yyf); (void) fputc ('\n', yyf);
  7159.  yWriteNodeFormal_generics1 (yyt); break;
  7160. case kFormal_generic: (void) fputs (Tree_NodeName [kFormal_generic], yyf); (void) fputc ('\n', yyf);
  7161.  yWriteNodeFormal_generic (yyt); break;
  7162. case kConstraint: (void) fputs (Tree_NodeName [kConstraint], yyf); (void) fputc ('\n', yyf);
  7163.  break;
  7164. case kConstraint0: (void) fputs (Tree_NodeName [kConstraint0], yyf); (void) fputc ('\n', yyf);
  7165.  break;
  7166. case kConstraint1: (void) fputs (Tree_NodeName [kConstraint1], yyf); (void) fputc ('\n', yyf);
  7167.  yWriteNodeConstraint1 (yyt); break;
  7168. case kCompound: (void) fputs (Tree_NodeName [kCompound], yyf); (void) fputc ('\n', yyf);
  7169.  break;
  7170. case kCompound0: (void) fputs (Tree_NodeName [kCompound0], yyf); (void) fputc ('\n', yyf);
  7171.  break;
  7172. case kCompound1: (void) fputs (Tree_NodeName [kCompound1], yyf); (void) fputc ('\n', yyf);
  7173.  yWriteNodeCompound1 (yyt); break;
  7174. case kThen_part_list: (void) fputs (Tree_NodeName [kThen_part_list], yyf); (void) fputc ('\n', yyf);
  7175.  break;
  7176. case kThen_part_list0: (void) fputs (Tree_NodeName [kThen_part_list0], yyf); (void) fputc ('\n', yyf);
  7177.  break;
  7178. case kThen_part_list1: (void) fputs (Tree_NodeName [kThen_part_list1], yyf); (void) fputc ('\n', yyf);
  7179.  yWriteNodeThen_part_list1 (yyt); break;
  7180. case kThen_part: (void) fputs (Tree_NodeName [kThen_part], yyf); (void) fputc ('\n', yyf);
  7181.  yWriteNodeThen_part (yyt); break;
  7182. case kWhen_part_list: (void) fputs (Tree_NodeName [kWhen_part_list], yyf); (void) fputc ('\n', yyf);
  7183.  break;
  7184. case kWhen_part_list0: (void) fputs (Tree_NodeName [kWhen_part_list0], yyf); (void) fputc ('\n', yyf);
  7185.  break;
  7186. case kWhen_part_list1: (void) fputs (Tree_NodeName [kWhen_part_list1], yyf); (void) fputc ('\n', yyf);
  7187.  yWriteNodeWhen_part_list1 (yyt); break;
  7188. case kWhen_part: (void) fputs (Tree_NodeName [kWhen_part], yyf); (void) fputc ('\n', yyf);
  7189.  yWriteNodeWhen_part (yyt); break;
  7190. case kChoices: (void) fputs (Tree_NodeName [kChoices], yyf); (void) fputc ('\n', yyf);
  7191.  break;
  7192. case kChoices0: (void) fputs (Tree_NodeName [kChoices0], yyf); (void) fputc ('\n', yyf);
  7193.  break;
  7194. case kChoices1: (void) fputs (Tree_NodeName [kChoices1], yyf); (void) fputc ('\n', yyf);
  7195.  yWriteNodeChoices1 (yyt); break;
  7196. case kChoice: (void) fputs (Tree_NodeName [kChoice], yyf); (void) fputc ('\n', yyf);
  7197.  break;
  7198. case kInterval: (void) fputs (Tree_NodeName [kInterval], yyf); (void) fputc ('\n', yyf);
  7199.  yWriteNodeInterval (yyt); break;
  7200. case kVal: (void) fputs (Tree_NodeName [kVal], yyf); (void) fputc ('\n', yyf);
  7201.  yWriteNodeVal (yyt); break;
  7202. case kInstruction: (void) fputs (Tree_NodeName [kInstruction], yyf); (void) fputc ('\n', yyf);
  7203.  break;
  7204. case kInstruction0: (void) fputs (Tree_NodeName [kInstruction0], yyf); (void) fputc ('\n', yyf);
  7205.  break;
  7206. case kCreation: (void) fputs (Tree_NodeName [kCreation], yyf); (void) fputc ('\n', yyf);
  7207.  yWriteNodeCreation (yyt); break;
  7208. case kCall_instruct: (void) fputs (Tree_NodeName [kCall_instruct], yyf); (void) fputc ('\n', yyf);
  7209.  yWriteNodeCall_instruct (yyt); break;
  7210. case kAssign: (void) fputs (Tree_NodeName [kAssign], yyf); (void) fputc ('\n', yyf);
  7211.  yWriteNodeAssign (yyt); break;
  7212. case kRev_assign: (void) fputs (Tree_NodeName [kRev_assign], yyf); (void) fputc ('\n', yyf);
  7213.  yWriteNodeRev_assign (yyt); break;
  7214. case kConditional: (void) fputs (Tree_NodeName [kConditional], yyf); (void) fputc ('\n', yyf);
  7215.  yWriteNodeConditional (yyt); break;
  7216. case kMulti_branch: (void) fputs (Tree_NodeName [kMulti_branch], yyf); (void) fputc ('\n', yyf);
  7217.  yWriteNodeMulti_branch (yyt); break;
  7218. case kLoop: (void) fputs (Tree_NodeName [kLoop], yyf); (void) fputc ('\n', yyf);
  7219.  yWriteNodeLoop (yyt); break;
  7220. case kCheck: (void) fputs (Tree_NodeName [kCheck], yyf); (void) fputc ('\n', yyf);
  7221.  yWriteNodeCheck (yyt); break;
  7222. case kDebug: (void) fputs (Tree_NodeName [kDebug], yyf); (void) fputc ('\n', yyf);
  7223.  yWriteNodeDebug (yyt); break;
  7224. case kRetry: (void) fputs (Tree_NodeName [kRetry], yyf); (void) fputc ('\n', yyf);
  7225.  yWriteNodeRetry (yyt); break;
  7226. case kLoop_body: (void) fputs (Tree_NodeName [kLoop_body], yyf); (void) fputc ('\n', yyf);
  7227.  break;
  7228. case kLoop_body0: (void) fputs (Tree_NodeName [kLoop_body0], yyf); (void) fputc ('\n', yyf);
  7229.  break;
  7230. case kLoop_body1: (void) fputs (Tree_NodeName [kLoop_body1], yyf); (void) fputc ('\n', yyf);
  7231.  yWriteNodeLoop_body1 (yyt); break;
  7232. case kType: (void) fputs (Tree_NodeName [kType], yyf); (void) fputc ('\n', yyf);
  7233.  break;
  7234. case kType0: (void) fputs (Tree_NodeName [kType0], yyf); (void) fputc ('\n', yyf);
  7235.  break;
  7236. case kClass_type: (void) fputs (Tree_NodeName [kClass_type], yyf); (void) fputc ('\n', yyf);
  7237.  yWriteNodeClass_type (yyt); break;
  7238. case kClass_type_expanded: (void) fputs (Tree_NodeName [kClass_type_expanded], yyf); (void) fputc ('\n', yyf);
  7239.  yWriteNodeClass_type_expanded (yyt); break;
  7240. case kBit_type: (void) fputs (Tree_NodeName [kBit_type], yyf); (void) fputc ('\n', yyf);
  7241.  yWriteNodeBit_type (yyt); break;
  7242. case kSimple_type: (void) fputs (Tree_NodeName [kSimple_type], yyf); (void) fputc ('\n', yyf);
  7243.  yWriteNodeSimple_type (yyt); break;
  7244. case kAnchored: (void) fputs (Tree_NodeName [kAnchored], yyf); (void) fputc ('\n', yyf);
  7245.  yWriteNodeAnchored (yyt); break;
  7246. case kActual_generics: (void) fputs (Tree_NodeName [kActual_generics], yyf); (void) fputc ('\n', yyf);
  7247.  break;
  7248. case kActual_generics0: (void) fputs (Tree_NodeName [kActual_generics0], yyf); (void) fputc ('\n', yyf);
  7249.  break;
  7250. case kActual_generics1: (void) fputs (Tree_NodeName [kActual_generics1], yyf); (void) fputc ('\n', yyf);
  7251.  yWriteNodeActual_generics1 (yyt); break;
  7252. case kCondition: (void) fputs (Tree_NodeName [kCondition], yyf); (void) fputc ('\n', yyf);
  7253.  break;
  7254. case kCondition0: (void) fputs (Tree_NodeName [kCondition0], yyf); (void) fputc ('\n', yyf);
  7255.  break;
  7256. case kCondition1: (void) fputs (Tree_NodeName [kCondition1], yyf); (void) fputc ('\n', yyf);
  7257.  yWriteNodeCondition1 (yyt); break;
  7258. case kAssertion: (void) fputs (Tree_NodeName [kAssertion], yyf); (void) fputc ('\n', yyf);
  7259.  break;
  7260. case kAssertion0: (void) fputs (Tree_NodeName [kAssertion0], yyf); (void) fputc ('\n', yyf);
  7261.  break;
  7262. case kAssertion1: (void) fputs (Tree_NodeName [kAssertion1], yyf); (void) fputc ('\n', yyf);
  7263.  yWriteNodeAssertion1 (yyt); break;
  7264. case kAssertion_clause: (void) fputs (Tree_NodeName [kAssertion_clause], yyf); (void) fputc ('\n', yyf);
  7265.  break;
  7266. case kAssertion_clause0: (void) fputs (Tree_NodeName [kAssertion_clause0], yyf); (void) fputc ('\n', yyf);
  7267.  break;
  7268. case kAssertion_clause1: (void) fputs (Tree_NodeName [kAssertion_clause1], yyf); (void) fputc ('\n', yyf);
  7269.  yWriteNodeAssertion_clause1 (yyt); break;
  7270. case kType_list: (void) fputs (Tree_NodeName [kType_list], yyf); (void) fputc ('\n', yyf);
  7271.  break;
  7272. case kType_list0: (void) fputs (Tree_NodeName [kType_list0], yyf); (void) fputc ('\n', yyf);
  7273.  break;
  7274. case kType_list1: (void) fputs (Tree_NodeName [kType_list1], yyf); (void) fputc ('\n', yyf);
  7275.  yWriteNodeType_list1 (yyt); break;
  7276. case kCall_chain: (void) fputs (Tree_NodeName [kCall_chain], yyf); (void) fputc ('\n', yyf);
  7277.  break;
  7278. case kCall_chain0: (void) fputs (Tree_NodeName [kCall_chain0], yyf); (void) fputc ('\n', yyf);
  7279.  break;
  7280. case kCall_chain1: (void) fputs (Tree_NodeName [kCall_chain1], yyf); (void) fputc ('\n', yyf);
  7281.  yWriteNodeCall_chain1 (yyt); break;
  7282. case kUnqual_call: (void) fputs (Tree_NodeName [kUnqual_call], yyf); (void) fputc ('\n', yyf);
  7283.  break;
  7284. case kUnqual_call0: (void) fputs (Tree_NodeName [kUnqual_call0], yyf); (void) fputc ('\n', yyf);
  7285.  break;
  7286. case kUnqual_call1: (void) fputs (Tree_NodeName [kUnqual_call1], yyf); (void) fputc ('\n', yyf);
  7287.  yWriteNodeUnqual_call1 (yyt); break;
  7288. case kActuals: (void) fputs (Tree_NodeName [kActuals], yyf); (void) fputc ('\n', yyf);
  7289.  break;
  7290. case kActuals0: (void) fputs (Tree_NodeName [kActuals0], yyf); (void) fputc ('\n', yyf);
  7291.  break;
  7292. case kActuals1: (void) fputs (Tree_NodeName [kActuals1], yyf); (void) fputc ('\n', yyf);
  7293.  yWriteNodeActuals1 (yyt); break;
  7294. case kActual_list: (void) fputs (Tree_NodeName [kActual_list], yyf); (void) fputc ('\n', yyf);
  7295.  break;
  7296. case kActual_list0: (void) fputs (Tree_NodeName [kActual_list0], yyf); (void) fputc ('\n', yyf);
  7297.  break;
  7298. case kActual_list1: (void) fputs (Tree_NodeName [kActual_list1], yyf); (void) fputc ('\n', yyf);
  7299.  yWriteNodeActual_list1 (yyt); break;
  7300. case kActual: (void) fputs (Tree_NodeName [kActual], yyf); (void) fputc ('\n', yyf);
  7301.  break;
  7302. case kAddr: (void) fputs (Tree_NodeName [kAddr], yyf); (void) fputc ('\n', yyf);
  7303.  yWriteNodeAddr (yyt); break;
  7304. case kExpression: (void) fputs (Tree_NodeName [kExpression], yyf); (void) fputc ('\n', yyf);
  7305.  break;
  7306. case kExpression0: (void) fputs (Tree_NodeName [kExpression0], yyf); (void) fputc ('\n', yyf);
  7307.  break;
  7308. case kComment: (void) fputs (Tree_NodeName [kComment], yyf); (void) fputc ('\n', yyf);
  7309.  yWriteNodeComment (yyt); break;
  7310. case kSimple_expr: (void) fputs (Tree_NodeName [kSimple_expr], yyf); (void) fputc ('\n', yyf);
  7311.  yWriteNodeSimple_expr (yyt); break;
  7312. case kCall: (void) fputs (Tree_NodeName [kCall], yyf); (void) fputc ('\n', yyf);
  7313.  yWriteNodeCall (yyt); break;
  7314. case kBin_expr: (void) fputs (Tree_NodeName [kBin_expr], yyf); (void) fputc ('\n', yyf);
  7315.  yWriteNodeBin_expr (yyt); break;
  7316. case kUn_expr: (void) fputs (Tree_NodeName [kUn_expr], yyf); (void) fputc ('\n', yyf);
  7317.  yWriteNodeUn_expr (yyt); break;
  7318. case kParenth: (void) fputs (Tree_NodeName [kParenth], yyf); (void) fputc ('\n', yyf);
  7319.  yWriteNodeParenth (yyt); break;
  7320. case kManifest_array: (void) fputs (Tree_NodeName [kManifest_array], yyf); (void) fputc ('\n', yyf);
  7321.  break;
  7322. case kManifest_array0: (void) fputs (Tree_NodeName [kManifest_array0], yyf); (void) fputc ('\n', yyf);
  7323.  break;
  7324. case kManifest_array1: (void) fputs (Tree_NodeName [kManifest_array1], yyf); (void) fputc ('\n', yyf);
  7325.  yWriteNodeManifest_array1 (yyt); break;
  7326. case kOld: (void) fputs (Tree_NodeName [kOld], yyf); (void) fputc ('\n', yyf);
  7327.  yWriteNodeOld (yyt); break;
  7328. case kStrip: (void) fputs (Tree_NodeName [kStrip], yyf); (void) fputc ('\n', yyf);
  7329.  yWriteNodeStrip (yyt); break;
  7330. case kList: (void) fputs (Tree_NodeName [kList], yyf); (void) fputc ('\n', yyf);
  7331.  break;
  7332. case knolist: (void) fputs (Tree_NodeName [knolist], yyf); (void) fputc ('\n', yyf);
  7333.  break;
  7334. case klist: (void) fputs (Tree_NodeName [klist], yyf); (void) fputc ('\n', yyf);
  7335.  yWriteNodelist (yyt); break;
  7336. case kManifest_constant: (void) fputs (Tree_NodeName [kManifest_constant], yyf); (void) fputc ('\n', yyf);
  7337.  break;
  7338. case kManifest_constant0: (void) fputs (Tree_NodeName [kManifest_constant0], yyf); (void) fputc ('\n', yyf);
  7339.  break;
  7340. case kCh: (void) fputs (Tree_NodeName [kCh], yyf); (void) fputc ('\n', yyf);
  7341.  yWriteNodeCh (yyt); break;
  7342. case kTrue: (void) fputs (Tree_NodeName [kTrue], yyf); (void) fputc ('\n', yyf);
  7343.  yWriteNodeTrue (yyt); break;
  7344. case kFalse: (void) fputs (Tree_NodeName [kFalse], yyf); (void) fputc ('\n', yyf);
  7345.  yWriteNodeFalse (yyt); break;
  7346. case kInt: (void) fputs (Tree_NodeName [kInt], yyf); (void) fputc ('\n', yyf);
  7347.  yWriteNodeInt (yyt); break;
  7348. case kReal: (void) fputs (Tree_NodeName [kReal], yyf); (void) fputc ('\n', yyf);
  7349.  yWriteNodeReal (yyt); break;
  7350. case k_CHARACTER: (void) fputs (Tree_NodeName [k_CHARACTER], yyf); (void) fputc ('\n', yyf);
  7351.  yWriteNode_CHARACTER (yyt); break;
  7352. case k_INTEGER: (void) fputs (Tree_NodeName [k_INTEGER], yyf); (void) fputc ('\n', yyf);
  7353.  yWriteNode_INTEGER (yyt); break;
  7354. case k_REAL: (void) fputs (Tree_NodeName [k_REAL], yyf); (void) fputc ('\n', yyf);
  7355.  yWriteNode_REAL (yyt); break;
  7356. case k_DOUBLE: (void) fputs (Tree_NodeName [k_DOUBLE], yyf); (void) fputc ('\n', yyf);
  7357.  yWriteNode_DOUBLE (yyt); break;
  7358. case k_BOOLEAN: (void) fputs (Tree_NodeName [k_BOOLEAN], yyf); (void) fputc ('\n', yyf);
  7359.  yWriteNode_BOOLEAN (yyt); break;
  7360. case k_STRING: (void) fputs (Tree_NodeName [k_STRING], yyf); (void) fputc ('\n', yyf);
  7361.  yWriteNode_STRING (yyt); break;
  7362. case k_BIT: (void) fputs (Tree_NodeName [k_BIT], yyf); (void) fputc ('\n', yyf);
  7363.  yWriteNode_BIT (yyt); break;
  7364. case k_NONE: (void) fputs (Tree_NodeName [k_NONE], yyf); (void) fputc ('\n', yyf);
  7365.  yWriteNode_NONE (yyt); break;
  7366. case kBitseq: (void) fputs (Tree_NodeName [kBitseq], yyf); (void) fputc ('\n', yyf);
  7367.  yWriteNodeBitseq (yyt); break;
  7368. case kString: (void) fputs (Tree_NodeName [kString], yyf); (void) fputc ('\n', yyf);
  7369.  yWriteNodeString (yyt); break;
  7370. case kString0: (void) fputs (Tree_NodeName [kString0], yyf); (void) fputc ('\n', yyf);
  7371.  break;
  7372. case kEntity: (void) fputs (Tree_NodeName [kEntity], yyf); (void) fputc ('\n', yyf);
  7373.  break;
  7374. case kEntity0: (void) fputs (Tree_NodeName [kEntity0], yyf); (void) fputc ('\n', yyf);
  7375.  break;
  7376. case kCurrent: (void) fputs (Tree_NodeName [kCurrent], yyf); (void) fputc ('\n', yyf);
  7377.  yWriteNodeCurrent (yyt); break;
  7378. case kResult: (void) fputs (Tree_NodeName [kResult], yyf); (void) fputc ('\n', yyf);
  7379.  yWriteNodeResult (yyt); break;
  7380. case kId: (void) fputs (Tree_NodeName [kId], yyf); (void) fputc ('\n', yyf);
  7381.  yWriteNodeId (yyt); break;
  7382.  default: ;
  7383.  }
  7384. }
  7385.  
  7386. static short yyIndentLevel;
  7387.  
  7388. void WriteTree
  7389. # if defined __STDC__ | defined __cplusplus
  7390.  (FILE * yyyf, tTree yyt)
  7391. # else
  7392.  (yyyf, yyt) FILE * yyyf; tTree yyt;
  7393. # endif
  7394. {
  7395.  short yySaveLevel = yyIndentLevel;
  7396.  yyf = yyyf;
  7397.  if (yyRecursionLevel ++ == 0) yyLabelCount = 0;
  7398.  yyMark (yyt);
  7399.  yyIndentLevel = 0;
  7400.  yyWriteTree (yyt);
  7401.  yyIndentLevel = yySaveLevel;
  7402.  yyRecursionLevel --;
  7403. }
  7404.  
  7405. static void yyIndentSelector
  7406. # if defined __STDC__ | defined __cplusplus
  7407.  (char * yys)
  7408. # else
  7409.  (yys) char * yys;
  7410. # endif
  7411. {
  7412.  register int yyi;
  7413.  for (yyi = 1; yyi <= yyIndentLevel; yyi ++) (void) putc (' ', yyf);
  7414.  yyWriteSelector (yys);
  7415. }
  7416.  
  7417. static void yyIndentSelectorTree
  7418. # if defined __STDC__ | defined __cplusplus
  7419.  (char * yys, tTree yyt)
  7420. # else
  7421.  (yys, yyt) char * yys; tTree yyt;
  7422. # endif
  7423. { yyIndentSelector (yys); writetTree (yyt) }
  7424.  
  7425. static void yWriteEiffel
  7426. # if defined __STDC__ | defined __cplusplus
  7427.  (tTree yyt)
  7428. # else
  7429.  (yyt) tTree yyt;
  7430. # endif
  7431. {
  7432.  (void) fputs (Tree_NodeName [kEiffel], yyf); (void) fputc ('\n', yyf);
  7433. }
  7434.  
  7435. static void yWriteClasses1
  7436. # if defined __STDC__ | defined __cplusplus
  7437.  (tTree yyt)
  7438. # else
  7439.  (yyt) tTree yyt;
  7440. # endif
  7441. {
  7442.  (void) fputs (Tree_NodeName [kClasses1], yyf); (void) fputc ('\n', yyf);
  7443.  yyIndentSelectorTree ("Class_declaration", yyt->Classes1.Class_declaration);
  7444. }
  7445.  
  7446. static void yWriteClass_declaration
  7447. # if defined __STDC__ | defined __cplusplus
  7448.  (tTree yyt)
  7449. # else
  7450.  (yyt) tTree yyt;
  7451. # endif
  7452. {
  7453.  (void) fputs (Tree_NodeName [kClass_declaration], yyf); (void) fputc ('\n', yyf);
  7454.  yyIndentSelectorTree ("Indexing", yyt->Class_declaration.Indexing);
  7455.  yyIndentSelectorTree ("Class_header", yyt->Class_declaration.Class_header);
  7456.  yyIndentSelectorTree ("Formal_generics", yyt->Class_declaration.Formal_generics);
  7457.  yyIndentSelectorTree ("Obsolete", yyt->Class_declaration.Obsolete);
  7458.  yyIndentSelectorTree ("Inheritance", yyt->Class_declaration.Inheritance);
  7459.  yyIndentSelectorTree ("Creators", yyt->Class_declaration.Creators);
  7460.  yyIndentSelectorTree ("Features", yyt->Class_declaration.Features);
  7461.  yyIndentSelector ("comment"); writetStringRef (yyt->Class_declaration.comment) yyWriteNl ();
  7462. }
  7463.  
  7464. static void yWriteIndex_list1
  7465. # if defined __STDC__ | defined __cplusplus
  7466.  (tTree yyt)
  7467. # else
  7468.  (yyt) tTree yyt;
  7469. # endif
  7470. {
  7471.  (void) fputs (Tree_NodeName [kIndex_list1], yyf); (void) fputc ('\n', yyf);
  7472.  yyIndentSelectorTree ("Index_clause", yyt->Index_list1.Index_clause);
  7473. }
  7474.  
  7475. static void yWriteIndex_clause
  7476. # if defined __STDC__ | defined __cplusplus
  7477.  (tTree yyt)
  7478. # else
  7479.  (yyt) tTree yyt;
  7480. # endif
  7481. {
  7482.  (void) fputs (Tree_NodeName [kIndex_clause], yyf); (void) fputc ('\n', yyf);
  7483.  yyIndentSelectorTree ("Index", yyt->Index_clause.Index);
  7484. }
  7485.  
  7486. static void yWriteClass
  7487. # if defined __STDC__ | defined __cplusplus
  7488.  (tTree yyt)
  7489. # else
  7490.  (yyt) tTree yyt;
  7491. # endif
  7492. {
  7493.  (void) fputs (Tree_NodeName [kClass], yyf); (void) fputc ('\n', yyf);
  7494. }
  7495.  
  7496. static void yWriteExpanded_class
  7497. # if defined __STDC__ | defined __cplusplus
  7498.  (tTree yyt)
  7499. # else
  7500.  (yyt) tTree yyt;
  7501. # endif
  7502. {
  7503.  (void) fputs (Tree_NodeName [kExpanded_class], yyf); (void) fputc ('\n', yyf);
  7504. }
  7505.  
  7506. static void yWriteDeferred_class
  7507. # if defined __STDC__ | defined __cplusplus
  7508.  (tTree yyt)
  7509. # else
  7510.  (yyt) tTree yyt;
  7511. # endif
  7512. {
  7513.  (void) fputs (Tree_NodeName [kDeferred_class], yyf); (void) fputc ('\n', yyf);
  7514. }
  7515.  
  7516. static void yWriteFeatures1
  7517. # if defined __STDC__ | defined __cplusplus
  7518.  (tTree yyt)
  7519. # else
  7520.  (yyt) tTree yyt;
  7521. # endif
  7522. {
  7523.  (void) fputs (Tree_NodeName [kFeatures1], yyf); (void) fputc ('\n', yyf);
  7524.  yyIndentSelectorTree ("Feature_clause", yyt->Features1.Feature_clause);
  7525. }
  7526.  
  7527. static void yWriteFeature_clause
  7528. # if defined __STDC__ | defined __cplusplus
  7529.  (tTree yyt)
  7530. # else
  7531.  (yyt) tTree yyt;
  7532. # endif
  7533. {
  7534.  (void) fputs (Tree_NodeName [kFeature_clause], yyf); (void) fputc ('\n', yyf);
  7535.  yyIndentSelectorTree ("Clients", yyt->Feature_clause.Clients);
  7536.  yyIndentSelector ("comment"); writetStringRef (yyt->Feature_clause.comment) yyWriteNl ();
  7537. }
  7538.  
  7539. static void yWriteClients1
  7540. # if defined __STDC__ | defined __cplusplus
  7541.  (tTree yyt)
  7542. # else
  7543.  (yyt) tTree yyt;
  7544. # endif
  7545. {
  7546.  (void) fputs (Tree_NodeName [kClients1], yyf); (void) fputc ('\n', yyf);
  7547. }
  7548.  
  7549. static void yWriteFeature_decls1
  7550. # if defined __STDC__ | defined __cplusplus
  7551.  (tTree yyt)
  7552. # else
  7553.  (yyt) tTree yyt;
  7554. # endif
  7555. {
  7556.  (void) fputs (Tree_NodeName [kFeature_decls1], yyf); (void) fputc ('\n', yyf);
  7557.  yyIndentSelectorTree ("Feature_decl", yyt->Feature_decls1.Feature_decl);
  7558. }
  7559.  
  7560. static void yWriteFeature_decl
  7561. # if defined __STDC__ | defined __cplusplus
  7562.  (tTree yyt)
  7563. # else
  7564.  (yyt) tTree yyt;
  7565. # endif
  7566. {
  7567.  (void) fputs (Tree_NodeName [kFeature_decl], yyf); (void) fputc ('\n', yyf);
  7568.  yyIndentSelectorTree ("New_feature_list", yyt->Feature_decl.New_feature_list);
  7569. }
  7570.  
  7571. static void yWriteDeclaration_body
  7572. # if defined __STDC__ | defined __cplusplus
  7573.  (tTree yyt)
  7574. # else
  7575.  (yyt) tTree yyt;
  7576. # endif
  7577. {
  7578.  (void) fputs (Tree_NodeName [kDeclaration_body], yyf); (void) fputc ('\n', yyf);
  7579.  yyIndentSelectorTree ("Formal_args", yyt->Declaration_body.Formal_args);
  7580.  yyIndentSelectorTree ("Type_mark", yyt->Declaration_body.Type_mark);
  7581. }
  7582.  
  7583. static void yWriteM_const
  7584. # if defined __STDC__ | defined __cplusplus
  7585.  (tTree yyt)
  7586. # else
  7587.  (yyt) tTree yyt;
  7588. # endif
  7589. {
  7590.  (void) fputs (Tree_NodeName [kM_const], yyf); (void) fputc ('\n', yyf);
  7591. }
  7592.  
  7593. static void yWriteUnique
  7594. # if defined __STDC__ | defined __cplusplus
  7595.  (tTree yyt)
  7596. # else
  7597.  (yyt) tTree yyt;
  7598. # endif
  7599. {
  7600.  (void) fputs (Tree_NodeName [kUnique], yyf); (void) fputc ('\n', yyf);
  7601.  yyIndentSelector ("pos"); writetPosition (yyt->Unique.pos) yyWriteNl ();
  7602. }
  7603.  
  7604. static void yWriteRoutine
  7605. # if defined __STDC__ | defined __cplusplus
  7606.  (tTree yyt)
  7607. # else
  7608.  (yyt) tTree yyt;
  7609. # endif
  7610. {
  7611.  (void) fputs (Tree_NodeName [kRoutine], yyf); (void) fputc ('\n', yyf);
  7612.  yyIndentSelectorTree ("Obsolete", yyt->Routine.Obsolete);
  7613.  yyIndentSelector ("comment"); writetStringRef (yyt->Routine.comment) yyWriteNl ();
  7614.  yyIndentSelectorTree ("Precondition", yyt->Routine.Precondition);
  7615.  yyIndentSelectorTree ("Local_decls", yyt->Routine.Local_decls);
  7616.  yyIndentSelectorTree ("Routine_body", yyt->Routine.Routine_body);
  7617.  yyIndentSelectorTree ("Postcondition", yyt->Routine.Postcondition);
  7618.  yyIndentSelector ("end_comment"); writetStringRef (yyt->Routine.end_comment) yyWriteNl ();
  7619. }
  7620.  
  7621. static void yWriteParent_list1
  7622. # if defined __STDC__ | defined __cplusplus
  7623.  (tTree yyt)
  7624. # else
  7625.  (yyt) tTree yyt;
  7626. # endif
  7627. {
  7628.  (void) fputs (Tree_NodeName [kParent_list1], yyf); (void) fputc ('\n', yyf);
  7629.  yyIndentSelectorTree ("Parent", yyt->Parent_list1.Parent);
  7630. }
  7631.  
  7632. static void yWriteParent
  7633. # if defined __STDC__ | defined __cplusplus
  7634.  (tTree yyt)
  7635. # else
  7636.  (yyt) tTree yyt;
  7637. # endif
  7638. {
  7639.  (void) fputs (Tree_NodeName [kParent], yyf); (void) fputc ('\n', yyf);
  7640.  yyIndentSelectorTree ("Class_type", yyt->Parent.Class_type);
  7641. }
  7642.  
  7643. static void yWriteFeature_adaptation1
  7644. # if defined __STDC__ | defined __cplusplus
  7645.  (tTree yyt)
  7646. # else
  7647.  (yyt) tTree yyt;
  7648. # endif
  7649. {
  7650.  (void) fputs (Tree_NodeName [kFeature_adaptation1], yyf); (void) fputc ('\n', yyf);
  7651.  yyIndentSelectorTree ("Rename", yyt->Feature_adaptation1.Rename);
  7652.  yyIndentSelectorTree ("New_export", yyt->Feature_adaptation1.New_export);
  7653.  yyIndentSelectorTree ("Undefine", yyt->Feature_adaptation1.Undefine);
  7654.  yyIndentSelectorTree ("Redefine", yyt->Feature_adaptation1.Redefine);
  7655. }
  7656.  
  7657. static void yWriteRename_list1
  7658. # if defined __STDC__ | defined __cplusplus
  7659.  (tTree yyt)
  7660. # else
  7661.  (yyt) tTree yyt;
  7662. # endif
  7663. {
  7664.  (void) fputs (Tree_NodeName [kRename_list1], yyf); (void) fputc ('\n', yyf);
  7665.  yyIndentSelectorTree ("Rename_pair", yyt->Rename_list1.Rename_pair);
  7666. }
  7667.  
  7668. static void yWriteRename_pair
  7669. # if defined __STDC__ | defined __cplusplus
  7670.  (tTree yyt)
  7671. # else
  7672.  (yyt) tTree yyt;
  7673. # endif
  7674. {
  7675.  (void) fputs (Tree_NodeName [kRename_pair], yyf); (void) fputc ('\n', yyf);
  7676.  yyIndentSelectorTree ("Name1", yyt->Rename_pair.Name1);
  7677. }
  7678.  
  7679. static void yWriteCreators1
  7680. # if defined __STDC__ | defined __cplusplus
  7681.  (tTree yyt)
  7682. # else
  7683.  (yyt) tTree yyt;
  7684. # endif
  7685. {
  7686.  (void) fputs (Tree_NodeName [kCreators1], yyf); (void) fputc ('\n', yyf);
  7687.  yyIndentSelectorTree ("Creation_clause", yyt->Creators1.Creation_clause);
  7688. }
  7689.  
  7690. static void yWriteCreation_clause
  7691. # if defined __STDC__ | defined __cplusplus
  7692.  (tTree yyt)
  7693. # else
  7694.  (yyt) tTree yyt;
  7695. # endif
  7696. {
  7697.  (void) fputs (Tree_NodeName [kCreation_clause], yyf); (void) fputc ('\n', yyf);
  7698.  yyIndentSelectorTree ("Clients", yyt->Creation_clause.Clients);
  7699.  yyIndentSelector ("comment"); writetStringRef (yyt->Creation_clause.comment) yyWriteNl ();
  7700. }
  7701.  
  7702. static void yWriteNew_feature_list1
  7703. # if defined __STDC__ | defined __cplusplus
  7704.  (tTree yyt)
  7705. # else
  7706.  (yyt) tTree yyt;
  7707. # endif
  7708. {
  7709.  (void) fputs (Tree_NodeName [kNew_feature_list1], yyf); (void) fputc ('\n', yyf);
  7710.  yyIndentSelectorTree ("Feature_name", yyt->New_feature_list1.Feature_name);
  7711. }
  7712.  
  7713. static void yWriteFrozen
  7714. # if defined __STDC__ | defined __cplusplus
  7715.  (tTree yyt)
  7716. # else
  7717.  (yyt) tTree yyt;
  7718. # endif
  7719. {
  7720.  (void) fputs (Tree_NodeName [kFrozen], yyf); (void) fputc ('\n', yyf);
  7721. }
  7722.  
  7723. static void yWriteIdent_name
  7724. # if defined __STDC__ | defined __cplusplus
  7725.  (tTree yyt)
  7726. # else
  7727.  (yyt) tTree yyt;
  7728. # endif
  7729. {
  7730.  (void) fputs (Tree_NodeName [kIdent_name], yyf); (void) fputc ('\n', yyf);
  7731. }
  7732.  
  7733. static void yWritePrefix
  7734. # if defined __STDC__ | defined __cplusplus
  7735.  (tTree yyt)
  7736. # else
  7737.  (yyt) tTree yyt;
  7738. # endif
  7739. {
  7740.  (void) fputs (Tree_NodeName [kPrefix], yyf); (void) fputc ('\n', yyf);
  7741. }
  7742.  
  7743. static void yWriteInfix
  7744. # if defined __STDC__ | defined __cplusplus
  7745.  (tTree yyt)
  7746. # else
  7747.  (yyt) tTree yyt;
  7748. # endif
  7749. {
  7750.  (void) fputs (Tree_NodeName [kInfix], yyf); (void) fputc ('\n', yyf);
  7751. }
  7752.  
  7753. static void yWriteOp_name
  7754. # if defined __STDC__ | defined __cplusplus
  7755.  (tTree yyt)
  7756. # else
  7757.  (yyt) tTree yyt;
  7758. # endif
  7759. {
  7760.  (void) fputs (Tree_NodeName [kOp_name], yyf); (void) fputc ('\n', yyf);
  7761.  yyIndentSelector ("pos"); writetPosition (yyt->Op_name.pos) yyWriteNl ();
  7762. }
  7763.  
  7764. static void yWriteFree_op
  7765. # if defined __STDC__ | defined __cplusplus
  7766.  (tTree yyt)
  7767. # else
  7768.  (yyt) tTree yyt;
  7769. # endif
  7770. {
  7771.  (void) fputs (Tree_NodeName [kFree_op], yyf); (void) fputc ('\n', yyf);
  7772.  yyIndentSelector ("pos"); writetPosition (yyt->Free_op.pos) yyWriteNl ();
  7773.  yyIndentSelector ("ident"); writetIdent (yyt->Free_op.ident) yyWriteNl ();
  7774. }
  7775.  
  7776. static void yWriteOper
  7777. # if defined __STDC__ | defined __cplusplus
  7778.  (tTree yyt)
  7779. # else
  7780.  (yyt) tTree yyt;
  7781. # endif
  7782. {
  7783.  (void) fputs (Tree_NodeName [kOper], yyf); (void) fputc ('\n', yyf);
  7784.  yyIndentSelector ("pos"); writetPosition (yyt->Oper.pos) yyWriteNl ();
  7785.  yyIndentSelector ("op"); writeint (yyt->Oper.op) yyWriteNl ();
  7786. }
  7787.  
  7788. static void yWriteNew_export_list1
  7789. # if defined __STDC__ | defined __cplusplus
  7790.  (tTree yyt)
  7791. # else
  7792.  (yyt) tTree yyt;
  7793. # endif
  7794. {
  7795.  (void) fputs (Tree_NodeName [kNew_export_list1], yyf); (void) fputc ('\n', yyf);
  7796.  yyIndentSelectorTree ("New_export_item", yyt->New_export_list1.New_export_item);
  7797. }
  7798.  
  7799. static void yWriteNew_export_item
  7800. # if defined __STDC__ | defined __cplusplus
  7801.  (tTree yyt)
  7802. # else
  7803.  (yyt) tTree yyt;
  7804. # endif
  7805. {
  7806.  (void) fputs (Tree_NodeName [kNew_export_item], yyf); (void) fputc ('\n', yyf);
  7807.  yyIndentSelectorTree ("Clients", yyt->New_export_item.Clients);
  7808. }
  7809.  
  7810. static void yWriteFeature_list1
  7811. # if defined __STDC__ | defined __cplusplus
  7812.  (tTree yyt)
  7813. # else
  7814.  (yyt) tTree yyt;
  7815. # endif
  7816. {
  7817.  (void) fputs (Tree_NodeName [kFeature_list1], yyf); (void) fputc ('\n', yyf);
  7818.  yyIndentSelectorTree ("Feature_name", yyt->Feature_list1.Feature_name);
  7819. }
  7820.  
  7821. static void yWriteFormal_args1
  7822. # if defined __STDC__ | defined __cplusplus
  7823.  (tTree yyt)
  7824. # else
  7825.  (yyt) tTree yyt;
  7826. # endif
  7827. {
  7828.  (void) fputs (Tree_NodeName [kFormal_args1], yyf); (void) fputc ('\n', yyf);
  7829.  yyIndentSelectorTree ("Entity_decl_group", yyt->Formal_args1.Entity_decl_group);
  7830. }
  7831.  
  7832. static void yWriteDo_body
  7833. # if defined __STDC__ | defined __cplusplus
  7834.  (tTree yyt)
  7835. # else
  7836.  (yyt) tTree yyt;
  7837. # endif
  7838. {
  7839.  (void) fputs (Tree_NodeName [kDo_body], yyf); (void) fputc ('\n', yyf);
  7840. }
  7841.  
  7842. static void yWriteOnce_body
  7843. # if defined __STDC__ | defined __cplusplus
  7844.  (tTree yyt)
  7845. # else
  7846.  (yyt) tTree yyt;
  7847. # endif
  7848. {
  7849.  (void) fputs (Tree_NodeName [kOnce_body], yyf); (void) fputc ('\n', yyf);
  7850. }
  7851.  
  7852. static void yWriteExternal
  7853. # if defined __STDC__ | defined __cplusplus
  7854.  (tTree yyt)
  7855. # else
  7856.  (yyt) tTree yyt;
  7857. # endif
  7858. {
  7859.  (void) fputs (Tree_NodeName [kExternal], yyf); (void) fputc ('\n', yyf);
  7860.  yyIndentSelectorTree ("Lang1", yyt->External.Lang1);
  7861. }
  7862.  
  7863. static void yWriteDeferred
  7864. # if defined __STDC__ | defined __cplusplus
  7865.  (tTree yyt)
  7866. # else
  7867.  (yyt) tTree yyt;
  7868. # endif
  7869. {
  7870.  (void) fputs (Tree_NodeName [kDeferred], yyf); (void) fputc ('\n', yyf);
  7871.  yyIndentSelector ("pos"); writetPosition (yyt->Deferred.pos) yyWriteNl ();
  7872. }
  7873.  
  7874. static void yWriteEntity_decl_group
  7875. # if defined __STDC__ | defined __cplusplus
  7876.  (tTree yyt)
  7877. # else
  7878.  (yyt) tTree yyt;
  7879. # endif
  7880. {
  7881.  (void) fputs (Tree_NodeName [kEntity_decl_group], yyf); (void) fputc ('\n', yyf);
  7882.  yyIndentSelectorTree ("Id_list", yyt->Entity_decl_group.Id_list);
  7883. }
  7884.  
  7885. static void yWriteFormal_generics1
  7886. # if defined __STDC__ | defined __cplusplus
  7887.  (tTree yyt)
  7888. # else
  7889.  (yyt) tTree yyt;
  7890. # endif
  7891. {
  7892.  (void) fputs (Tree_NodeName [kFormal_generics1], yyf); (void) fputc ('\n', yyf);
  7893.  yyIndentSelectorTree ("Formal_generic", yyt->Formal_generics1.Formal_generic);
  7894. }
  7895.  
  7896. static void yWriteFormal_generic
  7897. # if defined __STDC__ | defined __cplusplus
  7898.  (tTree yyt)
  7899. # else
  7900.  (yyt) tTree yyt;
  7901. # endif
  7902. {
  7903.  (void) fputs (Tree_NodeName [kFormal_generic], yyf); (void) fputc ('\n', yyf);
  7904.  yyIndentSelectorTree ("Id", yyt->Formal_generic.Id);
  7905. }
  7906.  
  7907. static void yWriteConstraint1
  7908. # if defined __STDC__ | defined __cplusplus
  7909.  (tTree yyt)
  7910. # else
  7911.  (yyt) tTree yyt;
  7912. # endif
  7913. {
  7914.  (void) fputs (Tree_NodeName [kConstraint1], yyf); (void) fputc ('\n', yyf);
  7915. }
  7916.  
  7917. static void yWriteCompound1
  7918. # if defined __STDC__ | defined __cplusplus
  7919.  (tTree yyt)
  7920. # else
  7921.  (yyt) tTree yyt;
  7922. # endif
  7923. {
  7924.  (void) fputs (Tree_NodeName [kCompound1], yyf); (void) fputc ('\n', yyf);
  7925.  yyIndentSelectorTree ("Instruction", yyt->Compound1.Instruction);
  7926. }
  7927.  
  7928. static void yWriteThen_part_list1
  7929. # if defined __STDC__ | defined __cplusplus
  7930.  (tTree yyt)
  7931. # else
  7932.  (yyt) tTree yyt;
  7933. # endif
  7934. {
  7935.  (void) fputs (Tree_NodeName [kThen_part_list1], yyf); (void) fputc ('\n', yyf);
  7936.  yyIndentSelectorTree ("Then_part", yyt->Then_part_list1.Then_part);
  7937. }
  7938.  
  7939. static void yWriteThen_part
  7940. # if defined __STDC__ | defined __cplusplus
  7941.  (tTree yyt)
  7942. # else
  7943.  (yyt) tTree yyt;
  7944. # endif
  7945. {
  7946.  (void) fputs (Tree_NodeName [kThen_part], yyf); (void) fputc ('\n', yyf);
  7947.  yyIndentSelectorTree ("Guard", yyt->Then_part.Guard);
  7948. }
  7949.  
  7950. static void yWriteWhen_part_list1
  7951. # if defined __STDC__ | defined __cplusplus
  7952.  (tTree yyt)
  7953. # else
  7954.  (yyt) tTree yyt;
  7955. # endif
  7956. {
  7957.  (void) fputs (Tree_NodeName [kWhen_part_list1], yyf); (void) fputc ('\n', yyf);
  7958.  yyIndentSelectorTree ("When_part", yyt->When_part_list1.When_part);
  7959. }
  7960.  
  7961. static void yWriteWhen_part
  7962. # if defined __STDC__ | defined __cplusplus
  7963.  (tTree yyt)
  7964. # else
  7965.  (yyt) tTree yyt;
  7966. # endif
  7967. {
  7968.  (void) fputs (Tree_NodeName [kWhen_part], yyf); (void) fputc ('\n', yyf);
  7969.  yyIndentSelectorTree ("Choices", yyt->When_part.Choices);
  7970. }
  7971.  
  7972. static void yWriteChoices1
  7973. # if defined __STDC__ | defined __cplusplus
  7974.  (tTree yyt)
  7975. # else
  7976.  (yyt) tTree yyt;
  7977. # endif
  7978. {
  7979.  (void) fputs (Tree_NodeName [kChoices1], yyf); (void) fputc ('\n', yyf);
  7980.  yyIndentSelectorTree ("Choice", yyt->Choices1.Choice);
  7981. }
  7982.  
  7983. static void yWriteInterval
  7984. # if defined __STDC__ | defined __cplusplus
  7985.  (tTree yyt)
  7986. # else
  7987.  (yyt) tTree yyt;
  7988. # endif
  7989. {
  7990.  (void) fputs (Tree_NodeName [kInterval], yyf); (void) fputc ('\n', yyf);
  7991.  yyIndentSelectorTree ("From", yyt->Interval.From);
  7992. }
  7993.  
  7994. static void yWriteVal
  7995. # if defined __STDC__ | defined __cplusplus
  7996.  (tTree yyt)
  7997. # else
  7998.  (yyt) tTree yyt;
  7999. # endif
  8000. {
  8001.  (void) fputs (Tree_NodeName [kVal], yyf); (void) fputc ('\n', yyf);
  8002. }
  8003.  
  8004. static void yWriteCreation
  8005. # if defined __STDC__ | defined __cplusplus
  8006.  (tTree yyt)
  8007. # else
  8008.  (yyt) tTree yyt;
  8009. # endif
  8010. {
  8011.  (void) fputs (Tree_NodeName [kCreation], yyf); (void) fputc ('\n', yyf);
  8012.  yyIndentSelectorTree ("Type", yyt->Creation.Type);
  8013.  yyIndentSelectorTree ("Entity", yyt->Creation.Entity);
  8014. }
  8015.  
  8016. static void yWriteCall_instruct
  8017. # if defined __STDC__ | defined __cplusplus
  8018.  (tTree yyt)
  8019. # else
  8020.  (yyt) tTree yyt;
  8021. # endif
  8022. {
  8023.  (void) fputs (Tree_NodeName [kCall_instruct], yyf); (void) fputc ('\n', yyf);
  8024. }
  8025.  
  8026. static void yWriteAssign
  8027. # if defined __STDC__ | defined __cplusplus
  8028.  (tTree yyt)
  8029. # else
  8030.  (yyt) tTree yyt;
  8031. # endif
  8032. {
  8033.  (void) fputs (Tree_NodeName [kAssign], yyf); (void) fputc ('\n', yyf);
  8034.  yyIndentSelectorTree ("Addr", yyt->Assign.Addr);
  8035. }
  8036.  
  8037. static void yWriteRev_assign
  8038. # if defined __STDC__ | defined __cplusplus
  8039.  (tTree yyt)
  8040. # else
  8041.  (yyt) tTree yyt;
  8042. # endif
  8043. {
  8044.  (void) fputs (Tree_NodeName [kRev_assign], yyf); (void) fputc ('\n', yyf);
  8045.  yyIndentSelectorTree ("Addr", yyt->Rev_assign.Addr);
  8046. }
  8047.  
  8048. static void yWriteConditional
  8049. # if defined __STDC__ | defined __cplusplus
  8050.  (tTree yyt)
  8051. # else
  8052.  (yyt) tTree yyt;
  8053. # endif
  8054. {
  8055.  (void) fputs (Tree_NodeName [kConditional], yyf); (void) fputc ('\n', yyf);
  8056.  yyIndentSelectorTree ("Then_part", yyt->Conditional.Then_part);
  8057. }
  8058.  
  8059. static void yWriteMulti_branch
  8060. # if defined __STDC__ | defined __cplusplus
  8061.  (tTree yyt)
  8062. # else
  8063.  (yyt) tTree yyt;
  8064. # endif
  8065. {
  8066.  (void) fputs (Tree_NodeName [kMulti_branch], yyf); (void) fputc ('\n', yyf);
  8067.  yyIndentSelectorTree ("Guard", yyt->Multi_branch.Guard);
  8068.  yyIndentSelectorTree ("When_part_list", yyt->Multi_branch.When_part_list);
  8069. }
  8070.  
  8071. static void yWriteLoop
  8072. # if defined __STDC__ | defined __cplusplus
  8073.  (tTree yyt)
  8074. # else
  8075.  (yyt) tTree yyt;
  8076. # endif
  8077. {
  8078.  (void) fputs (Tree_NodeName [kLoop], yyf); (void) fputc ('\n', yyf);
  8079.  yyIndentSelectorTree ("Initialization", yyt->Loop.Initialization);
  8080.  yyIndentSelectorTree ("Invariant", yyt->Loop.Invariant);
  8081.  yyIndentSelectorTree ("Variant", yyt->Loop.Variant);
  8082. }
  8083.  
  8084. static void yWriteCheck
  8085. # if defined __STDC__ | defined __cplusplus
  8086.  (tTree yyt)
  8087. # else
  8088.  (yyt) tTree yyt;
  8089. # endif
  8090. {
  8091.  (void) fputs (Tree_NodeName [kCheck], yyf); (void) fputc ('\n', yyf);
  8092. }
  8093.  
  8094. static void yWriteDebug
  8095. # if defined __STDC__ | defined __cplusplus
  8096.  (tTree yyt)
  8097. # else
  8098.  (yyt) tTree yyt;
  8099. # endif
  8100. {
  8101.  (void) fputs (Tree_NodeName [kDebug], yyf); (void) fputc ('\n', yyf);
  8102.  yyIndentSelectorTree ("Debug_keys", yyt->Debug.Debug_keys);
  8103. }
  8104.  
  8105. static void yWriteRetry
  8106. # if defined __STDC__ | defined __cplusplus
  8107.  (tTree yyt)
  8108. # else
  8109.  (yyt) tTree yyt;
  8110. # endif
  8111. {
  8112.  (void) fputs (Tree_NodeName [kRetry], yyf); (void) fputc ('\n', yyf);
  8113.  yyIndentSelector ("pos"); writetPosition (yyt->Retry.pos) yyWriteNl ();
  8114. }
  8115.  
  8116. static void yWriteLoop_body1
  8117. # if defined __STDC__ | defined __cplusplus
  8118.  (tTree yyt)
  8119. # else
  8120.  (yyt) tTree yyt;
  8121. # endif
  8122. {
  8123.  (void) fputs (Tree_NodeName [kLoop_body1], yyf); (void) fputc ('\n', yyf);
  8124.  yyIndentSelectorTree ("Exit", yyt->Loop_body1.Exit);
  8125. }
  8126.  
  8127. static void yWriteClass_type
  8128. # if defined __STDC__ | defined __cplusplus
  8129.  (tTree yyt)
  8130. # else
  8131.  (yyt) tTree yyt;
  8132. # endif
  8133. {
  8134.  (void) fputs (Tree_NodeName [kClass_type], yyf); (void) fputc ('\n', yyf);
  8135.  yyIndentSelectorTree ("Id", yyt->Class_type.Id);
  8136. }
  8137.  
  8138. static void yWriteClass_type_expanded
  8139. # if defined __STDC__ | defined __cplusplus
  8140.  (tTree yyt)
  8141. # else
  8142.  (yyt) tTree yyt;
  8143. # endif
  8144. {
  8145.  (void) fputs (Tree_NodeName [kClass_type_expanded], yyf); (void) fputc ('\n', yyf);
  8146.  yyIndentSelectorTree ("Id", yyt->Class_type_expanded.Id);
  8147. }
  8148.  
  8149. static void yWriteBit_type
  8150. # if defined __STDC__ | defined __cplusplus
  8151.  (tTree yyt)
  8152. # else
  8153.  (yyt) tTree yyt;
  8154. # endif
  8155. {
  8156.  (void) fputs (Tree_NodeName [kBit_type], yyf); (void) fputc ('\n', yyf);
  8157. }
  8158.  
  8159. static void yWriteSimple_type
  8160. # if defined __STDC__ | defined __cplusplus
  8161.  (tTree yyt)
  8162. # else
  8163.  (yyt) tTree yyt;
  8164. # endif
  8165. {
  8166.  (void) fputs (Tree_NodeName [kSimple_type], yyf); (void) fputc ('\n', yyf);
  8167. }
  8168.  
  8169. static void yWriteAnchored
  8170. # if defined __STDC__ | defined __cplusplus
  8171.  (tTree yyt)
  8172. # else
  8173.  (yyt) tTree yyt;
  8174. # endif
  8175. {
  8176.  (void) fputs (Tree_NodeName [kAnchored], yyf); (void) fputc ('\n', yyf);
  8177. }
  8178.  
  8179. static void yWriteActual_generics1
  8180. # if defined __STDC__ | defined __cplusplus
  8181.  (tTree yyt)
  8182. # else
  8183.  (yyt) tTree yyt;
  8184. # endif
  8185. {
  8186.  (void) fputs (Tree_NodeName [kActual_generics1], yyf); (void) fputc ('\n', yyf);
  8187. }
  8188.  
  8189. static void yWriteCondition1
  8190. # if defined __STDC__ | defined __cplusplus
  8191.  (tTree yyt)
  8192. # else
  8193.  (yyt) tTree yyt;
  8194. # endif
  8195. {
  8196.  (void) fputs (Tree_NodeName [kCondition1], yyf); (void) fputc ('\n', yyf);
  8197.  yyIndentSelector ("extension"); writeint (yyt->Condition1.extension) yyWriteNl ();
  8198. }
  8199.  
  8200. static void yWriteAssertion1
  8201. # if defined __STDC__ | defined __cplusplus
  8202.  (tTree yyt)
  8203. # else
  8204.  (yyt) tTree yyt;
  8205. # endif
  8206. {
  8207.  (void) fputs (Tree_NodeName [kAssertion1], yyf); (void) fputc ('\n', yyf);
  8208.  yyIndentSelectorTree ("Assertion_clause", yyt->Assertion1.Assertion_clause);
  8209. }
  8210.  
  8211. static void yWriteAssertion_clause1
  8212. # if defined __STDC__ | defined __cplusplus
  8213.  (tTree yyt)
  8214. # else
  8215.  (yyt) tTree yyt;
  8216. # endif
  8217. {
  8218.  (void) fputs (Tree_NodeName [kAssertion_clause1], yyf); (void) fputc ('\n', yyf);
  8219.  yyIndentSelectorTree ("Tag", yyt->Assertion_clause1.Tag);
  8220. }
  8221.  
  8222. static void yWriteType_list1
  8223. # if defined __STDC__ | defined __cplusplus
  8224.  (tTree yyt)
  8225. # else
  8226.  (yyt) tTree yyt;
  8227. # endif
  8228. {
  8229.  (void) fputs (Tree_NodeName [kType_list1], yyf); (void) fputc ('\n', yyf);
  8230.  yyIndentSelectorTree ("Type", yyt->Type_list1.Type);
  8231. }
  8232.  
  8233. static void yWriteCall_chain1
  8234. # if defined __STDC__ | defined __cplusplus
  8235.  (tTree yyt)
  8236. # else
  8237.  (yyt) tTree yyt;
  8238. # endif
  8239. {
  8240.  (void) fputs (Tree_NodeName [kCall_chain1], yyf); (void) fputc ('\n', yyf);
  8241.  yyIndentSelectorTree ("Unqual_call", yyt->Call_chain1.Unqual_call);
  8242. }
  8243.  
  8244. static void yWriteUnqual_call1
  8245. # if defined __STDC__ | defined __cplusplus
  8246.  (tTree yyt)
  8247. # else
  8248.  (yyt) tTree yyt;
  8249. # endif
  8250. {
  8251.  (void) fputs (Tree_NodeName [kUnqual_call1], yyf); (void) fputc ('\n', yyf);
  8252.  yyIndentSelectorTree ("Entity", yyt->Unqual_call1.Entity);
  8253. }
  8254.  
  8255. static void yWriteActuals1
  8256. # if defined __STDC__ | defined __cplusplus
  8257.  (tTree yyt)
  8258. # else
  8259.  (yyt) tTree yyt;
  8260. # endif
  8261. {
  8262.  (void) fputs (Tree_NodeName [kActuals1], yyf); (void) fputc ('\n', yyf);
  8263. }
  8264.  
  8265. static void yWriteActual_list1
  8266. # if defined __STDC__ | defined __cplusplus
  8267.  (tTree yyt)
  8268. # else
  8269.  (yyt) tTree yyt;
  8270. # endif
  8271. {
  8272.  (void) fputs (Tree_NodeName [kActual_list1], yyf); (void) fputc ('\n', yyf);
  8273.  yyIndentSelectorTree ("Actual", yyt->Actual_list1.Actual);
  8274. }
  8275.  
  8276. static void yWriteAddr
  8277. # if defined __STDC__ | defined __cplusplus
  8278.  (tTree yyt)
  8279. # else
  8280.  (yyt) tTree yyt;
  8281. # endif
  8282. {
  8283.  (void) fputs (Tree_NodeName [kAddr], yyf); (void) fputc ('\n', yyf);
  8284. }
  8285.  
  8286. static void yWriteComment
  8287. # if defined __STDC__ | defined __cplusplus
  8288.  (tTree yyt)
  8289. # else
  8290.  (yyt) tTree yyt;
  8291. # endif
  8292. {
  8293.  (void) fputs (Tree_NodeName [kComment], yyf); (void) fputc ('\n', yyf);
  8294.  yyIndentSelector ("comment"); writetStringRef (yyt->Comment.comment) yyWriteNl ();
  8295. }
  8296.  
  8297. static void yWriteSimple_expr
  8298. # if defined __STDC__ | defined __cplusplus
  8299.  (tTree yyt)
  8300. # else
  8301.  (yyt) tTree yyt;
  8302. # endif
  8303. {
  8304.  (void) fputs (Tree_NodeName [kSimple_expr], yyf); (void) fputc ('\n', yyf);
  8305. }
  8306.  
  8307. static void yWriteCall
  8308. # if defined __STDC__ | defined __cplusplus
  8309.  (tTree yyt)
  8310. # else
  8311.  (yyt) tTree yyt;
  8312. # endif
  8313. {
  8314.  (void) fputs (Tree_NodeName [kCall], yyf); (void) fputc ('\n', yyf);
  8315.  yyIndentSelectorTree ("Qual", yyt->Call.Qual);
  8316. }
  8317.  
  8318. static void yWriteBin_expr
  8319. # if defined __STDC__ | defined __cplusplus
  8320.  (tTree yyt)
  8321. # else
  8322.  (yyt) tTree yyt;
  8323. # endif
  8324. {
  8325.  (void) fputs (Tree_NodeName [kBin_expr], yyf); (void) fputc ('\n', yyf);
  8326.  yyIndentSelectorTree ("Lop", yyt->Bin_expr.Lop);
  8327.  yyIndentSelectorTree ("Op", yyt->Bin_expr.Op);
  8328. }
  8329.  
  8330. static void yWriteUn_expr
  8331. # if defined __STDC__ | defined __cplusplus
  8332.  (tTree yyt)
  8333. # else
  8334.  (yyt) tTree yyt;
  8335. # endif
  8336. {
  8337.  (void) fputs (Tree_NodeName [kUn_expr], yyf); (void) fputc ('\n', yyf);
  8338.  yyIndentSelectorTree ("Op", yyt->Un_expr.Op);
  8339. }
  8340.  
  8341. static void yWriteParenth
  8342. # if defined __STDC__ | defined __cplusplus
  8343.  (tTree yyt)
  8344. # else
  8345.  (yyt) tTree yyt;
  8346. # endif
  8347. {
  8348.  (void) fputs (Tree_NodeName [kParenth], yyf); (void) fputc ('\n', yyf);
  8349. }
  8350.  
  8351. static void yWriteManifest_array1
  8352. # if defined __STDC__ | defined __cplusplus
  8353.  (tTree yyt)
  8354. # else
  8355.  (yyt) tTree yyt;
  8356. # endif
  8357. {
  8358.  (void) fputs (Tree_NodeName [kManifest_array1], yyf); (void) fputc ('\n', yyf);
  8359.  yyIndentSelectorTree ("Expression", yyt->Manifest_array1.Expression);
  8360. }
  8361.  
  8362. static void yWriteOld
  8363. # if defined __STDC__ | defined __cplusplus
  8364.  (tTree yyt)
  8365. # else
  8366.  (yyt) tTree yyt;
  8367. # endif
  8368. {
  8369.  (void) fputs (Tree_NodeName [kOld], yyf); (void) fputc ('\n', yyf);
  8370. }
  8371.  
  8372. static void yWriteStrip
  8373. # if defined __STDC__ | defined __cplusplus
  8374.  (tTree yyt)
  8375. # else
  8376.  (yyt) tTree yyt;
  8377. # endif
  8378. {
  8379.  (void) fputs (Tree_NodeName [kStrip], yyf); (void) fputc ('\n', yyf);
  8380. }
  8381.  
  8382. static void yWritelist
  8383. # if defined __STDC__ | defined __cplusplus
  8384.  (tTree yyt)
  8385. # else
  8386.  (yyt) tTree yyt;
  8387. # endif
  8388. {
  8389.  (void) fputs (Tree_NodeName [klist], yyf); (void) fputc ('\n', yyf);
  8390.  yyIndentSelectorTree ("Manifest_constant", yyt->list.Manifest_constant);
  8391. }
  8392.  
  8393. static void yWriteCh
  8394. # if defined __STDC__ | defined __cplusplus
  8395.  (tTree yyt)
  8396. # else
  8397.  (yyt) tTree yyt;
  8398. # endif
  8399. {
  8400.  (void) fputs (Tree_NodeName [kCh], yyf); (void) fputc ('\n', yyf);
  8401.  yyIndentSelector ("ch"); writeint (yyt->Ch.ch) yyWriteNl ();
  8402.  yyIndentSelector ("pos"); writetPosition (yyt->Ch.pos) yyWriteNl ();
  8403. }
  8404.  
  8405. static void yWriteTrue
  8406. # if defined __STDC__ | defined __cplusplus
  8407.  (tTree yyt)
  8408. # else
  8409.  (yyt) tTree yyt;
  8410. # endif
  8411. {
  8412.  (void) fputs (Tree_NodeName [kTrue], yyf); (void) fputc ('\n', yyf);
  8413.  yyIndentSelector ("pos"); writetPosition (yyt->True.pos) yyWriteNl ();
  8414. }
  8415.  
  8416. static void yWriteFalse
  8417. # if defined __STDC__ | defined __cplusplus
  8418.  (tTree yyt)
  8419. # else
  8420.  (yyt) tTree yyt;
  8421. # endif
  8422. {
  8423.  (void) fputs (Tree_NodeName [kFalse], yyf); (void) fputc ('\n', yyf);
  8424.  yyIndentSelector ("pos"); writetPosition (yyt->False.pos) yyWriteNl ();
  8425. }
  8426.  
  8427. static void yWriteInt
  8428. # if defined __STDC__ | defined __cplusplus
  8429.  (tTree yyt)
  8430. # else
  8431.  (yyt) tTree yyt;
  8432. # endif
  8433. {
  8434.  (void) fputs (Tree_NodeName [kInt], yyf); (void) fputc ('\n', yyf);
  8435.  yyIndentSelector ("value"); writelong (yyt->Int.value) yyWriteNl ();
  8436.  yyIndentSelector ("pos"); writetPosition (yyt->Int.pos) yyWriteNl ();
  8437. }
  8438.  
  8439. static void yWriteReal
  8440. # if defined __STDC__ | defined __cplusplus
  8441.  (tTree yyt)
  8442. # else
  8443.  (yyt) tTree yyt;
  8444. # endif
  8445. {
  8446.  (void) fputs (Tree_NodeName [kReal], yyf); (void) fputc ('\n', yyf);
  8447.  yyIndentSelector ("value"); writedouble (yyt->Real.value) yyWriteNl ();
  8448.  yyIndentSelector ("pos"); writetPosition (yyt->Real.pos) yyWriteNl ();
  8449. }
  8450.  
  8451. static void yWrite_CHARACTER
  8452. # if defined __STDC__ | defined __cplusplus
  8453.  (tTree yyt)
  8454. # else
  8455.  (yyt) tTree yyt;
  8456. # endif
  8457. {
  8458.  (void) fputs (Tree_NodeName [k_CHARACTER], yyf); (void) fputc ('\n', yyf);
  8459.  yyIndentSelector ("pos"); writetPosition (yyt->_CHARACTER.pos) yyWriteNl ();
  8460. }
  8461.  
  8462. static void yWrite_INTEGER
  8463. # if defined __STDC__ | defined __cplusplus
  8464.  (tTree yyt)
  8465. # else
  8466.  (yyt) tTree yyt;
  8467. # endif
  8468. {
  8469.  (void) fputs (Tree_NodeName [k_INTEGER], yyf); (void) fputc ('\n', yyf);
  8470.  yyIndentSelector ("pos"); writetPosition (yyt->_INTEGER.pos) yyWriteNl ();
  8471. }
  8472.  
  8473. static void yWrite_REAL
  8474. # if defined __STDC__ | defined __cplusplus
  8475.  (tTree yyt)
  8476. # else
  8477.  (yyt) tTree yyt;
  8478. # endif
  8479. {
  8480.  (void) fputs (Tree_NodeName [k_REAL], yyf); (void) fputc ('\n', yyf);
  8481.  yyIndentSelector ("pos"); writetPosition (yyt->_REAL.pos) yyWriteNl ();
  8482. }
  8483.  
  8484. static void yWrite_DOUBLE
  8485. # if defined __STDC__ | defined __cplusplus
  8486.  (tTree yyt)
  8487. # else
  8488.  (yyt) tTree yyt;
  8489. # endif
  8490. {
  8491.  (void) fputs (Tree_NodeName [k_DOUBLE], yyf); (void) fputc ('\n', yyf);
  8492.  yyIndentSelector ("pos"); writetPosition (yyt->_DOUBLE.pos) yyWriteNl ();
  8493. }
  8494.  
  8495. static void yWrite_BOOLEAN
  8496. # if defined __STDC__ | defined __cplusplus
  8497.  (tTree yyt)
  8498. # else
  8499.  (yyt) tTree yyt;
  8500. # endif
  8501. {
  8502.  (void) fputs (Tree_NodeName [k_BOOLEAN], yyf); (void) fputc ('\n', yyf);
  8503.  yyIndentSelector ("pos"); writetPosition (yyt->_BOOLEAN.pos) yyWriteNl ();
  8504. }
  8505.  
  8506. static void yWrite_STRING
  8507. # if defined __STDC__ | defined __cplusplus
  8508.  (tTree yyt)
  8509. # else
  8510.  (yyt) tTree yyt;
  8511. # endif
  8512. {
  8513.  (void) fputs (Tree_NodeName [k_STRING], yyf); (void) fputc ('\n', yyf);
  8514.  yyIndentSelector ("pos"); writetPosition (yyt->_STRING.pos) yyWriteNl ();
  8515. }
  8516.  
  8517. static void yWrite_BIT
  8518. # if defined __STDC__ | defined __cplusplus
  8519.  (tTree yyt)
  8520. # else
  8521.  (yyt) tTree yyt;
  8522. # endif
  8523. {
  8524.  (void) fputs (Tree_NodeName [k_BIT], yyf); (void) fputc ('\n', yyf);
  8525.  yyIndentSelector ("pos"); writetPosition (yyt->_BIT.pos) yyWriteNl ();
  8526. }
  8527.  
  8528. static void yWrite_NONE
  8529. # if defined __STDC__ | defined __cplusplus
  8530.  (tTree yyt)
  8531. # else
  8532.  (yyt) tTree yyt;
  8533. # endif
  8534. {
  8535.  (void) fputs (Tree_NodeName [k_NONE], yyf); (void) fputc ('\n', yyf);
  8536.  yyIndentSelector ("pos"); writetPosition (yyt->_NONE.pos) yyWriteNl ();
  8537. }
  8538.  
  8539. static void yWriteBitseq
  8540. # if defined __STDC__ | defined __cplusplus
  8541.  (tTree yyt)
  8542. # else
  8543.  (yyt) tTree yyt;
  8544. # endif
  8545. {
  8546.  (void) fputs (Tree_NodeName [kBitseq], yyf); (void) fputc ('\n', yyf);
  8547.  yyIndentSelector ("literal"); writetStringRef (yyt->Bitseq.literal) yyWriteNl ();
  8548.  yyIndentSelector ("pos"); writetPosition (yyt->Bitseq.pos) yyWriteNl ();
  8549. }
  8550.  
  8551. static void yWriteString
  8552. # if defined __STDC__ | defined __cplusplus
  8553.  (tTree yyt)
  8554. # else
  8555.  (yyt) tTree yyt;
  8556. # endif
  8557. {
  8558.  (void) fputs (Tree_NodeName [kString], yyf); (void) fputc ('\n', yyf);
  8559.  yyIndentSelector ("string"); writetStringRef (yyt->String.string) yyWriteNl ();
  8560.  yyIndentSelector ("pos"); writetPosition (yyt->String.pos) yyWriteNl ();
  8561. }
  8562.  
  8563. static void yWriteCurrent
  8564. # if defined __STDC__ | defined __cplusplus
  8565.  (tTree yyt)
  8566. # else
  8567.  (yyt) tTree yyt;
  8568. # endif
  8569. {
  8570.  (void) fputs (Tree_NodeName [kCurrent], yyf); (void) fputc ('\n', yyf);
  8571.  yyIndentSelector ("pos"); writetPosition (yyt->Current.pos) yyWriteNl ();
  8572. }
  8573.  
  8574. static void yWriteResult
  8575. # if defined __STDC__ | defined __cplusplus
  8576.  (tTree yyt)
  8577. # else
  8578.  (yyt) tTree yyt;
  8579. # endif
  8580. {
  8581.  (void) fputs (Tree_NodeName [kResult], yyf); (void) fputc ('\n', yyf);
  8582.  yyIndentSelector ("pos"); writetPosition (yyt->Result.pos) yyWriteNl ();
  8583. }
  8584.  
  8585. static void yWriteId
  8586. # if defined __STDC__ | defined __cplusplus
  8587.  (tTree yyt)
  8588. # else
  8589.  (yyt) tTree yyt;
  8590. # endif
  8591. {
  8592.  (void) fputs (Tree_NodeName [kId], yyf); (void) fputc ('\n', yyf);
  8593.  yyIndentSelector ("ident"); writetIdent (yyt->Id.ident) yyWriteNl ();
  8594.  yyIndentSelector ("pos"); writetPosition (yyt->Id.pos) yyWriteNl ();
  8595. }
  8596.  
  8597. static void yyWriteTree
  8598. # if defined __STDC__ | defined __cplusplus
  8599.  (tTree yyt)
  8600. # else
  8601.  (yyt) tTree yyt;
  8602. # endif
  8603. { unsigned short yyLevel = yyIndentLevel;
  8604.  for (;;) {
  8605.   if (yyt == NoTree) { (void) fputs (" NoTree\n", yyf); goto yyExit;
  8606.   } else if (yyt->yyHead.yyMark == 0) { (void) fprintf (yyf, "^%d\n", yyMapToLabel (yyt)); goto yyExit;
  8607.   } else if (yyt->yyHead.yyMark > 1) {
  8608.    register int yyi;
  8609.    (void) fprintf (yyf, "\n%06d:", yyMapToLabel (yyt));
  8610.    for (yyi = 8; yyi <= yyIndentLevel; yyi ++) (void) putc (' ', yyf);
  8611.   } else (void) putc (' ', yyf);
  8612.   yyt->yyHead.yyMark = 0;
  8613.   yyIndentLevel += 2;
  8614.  
  8615.   switch (yyt->Kind) {
  8616. case kEiffel: yWriteEiffel (yyt); yyIndentSelector ("Classes"); yyt = yyt->Eiffel.Classes; break;
  8617. case kClasses: (void) fputs (Tree_NodeName [kClasses], yyf); (void) fputc ('\n', yyf); goto yyExit;
  8618. case kClasses0: (void) fputs (Tree_NodeName [kClasses0], yyf); (void) fputc ('\n', yyf); goto yyExit;
  8619. case kClasses1: yWriteClasses1 (yyt); yyIndentSelector ("Classes"); yyt = yyt->Classes1.Classes; break;
  8620. case kClass_declaration: yWriteClass_declaration (yyt); yyIndentSelector ("Invariant"); yyt = yyt->Class_declaration.Invariant; break;
  8621. case kIndex_list: (void) fputs (Tree_NodeName [kIndex_list], yyf); (void) fputc ('\n', yyf); goto yyExit;
  8622. case kIndex_list0: (void) fputs (Tree_NodeName [kIndex_list0], yyf); (void) fputc ('\n', yyf); goto yyExit;
  8623. case kIndex_list1: yWriteIndex_list1 (yyt); yyIndentSelector ("Index_list"); yyt = yyt->Index_list1.Index_list; break;
  8624. case kIndex_clause: yWriteIndex_clause (yyt); yyIndentSelector ("Index_terms"); yyt = yyt->Index_clause.Index_terms; break;
  8625. case kClass_header: (void) fputs (Tree_NodeName [kClass_header], yyf); (void) fputc ('\n', yyf); goto yyExit;
  8626. case kClass_header0: (void) fputs (Tree_NodeName [kClass_header0], yyf); (void) fputc ('\n', yyf); goto yyExit;
  8627. case kClass: yWriteClass (yyt); yyIndentSelector ("Name"); yyt = yyt->Class.Name; break;
  8628. case kExpanded_class: yWriteExpanded_class (yyt); yyIndentSelector ("Name"); yyt = yyt->Expanded_class.Name; break;
  8629. case kDeferred_class: yWriteDeferred_class (yyt); yyIndentSelector ("Name"); yyt = yyt->Deferred_class.Name; break;
  8630. case kFeatures: (void) fputs (Tree_NodeName [kFeatures], yyf); (void) fputc ('\n', yyf); goto yyExit;
  8631. case kFeatures0: (void) fputs (Tree_NodeName [kFeatures0], yyf); (void) fputc ('\n', yyf); goto yyExit;
  8632. case kFeatures1: yWriteFeatures1 (yyt); yyIndentSelector ("Features"); yyt = yyt->Features1.Features; break;
  8633. case kFeature_clause: yWriteFeature_clause (yyt); yyIndentSelector ("Feature_decls"); yyt = yyt->Feature_clause.Feature_decls; break;
  8634. case kClients: (void) fputs (Tree_NodeName [kClients], yyf); (void) fputc ('\n', yyf); goto yyExit;
  8635. case kClients0: (void) fputs (Tree_NodeName [kClients0], yyf); (void) fputc ('\n', yyf); goto yyExit;
  8636. case kClients1: yWriteClients1 (yyt); yyIndentSelector ("List"); yyt = yyt->Clients1.List; break;
  8637. case kFeature_decls: (void) fputs (Tree_NodeName [kFeature_decls], yyf); (void) fputc ('\n', yyf); goto yyExit;
  8638. case kFeature_decls0: (void) fputs (Tree_NodeName [kFeature_decls0], yyf); (void) fputc ('\n', yyf); goto yyExit;
  8639. case kFeature_decls1: yWriteFeature_decls1 (yyt); yyIndentSelector ("Feature_decls"); yyt = yyt->Feature_decls1.Feature_decls; break;
  8640. case kFeature_decl: yWriteFeature_decl (yyt); yyIndentSelector ("Declaration_body"); yyt = yyt->Feature_decl.Declaration_body; break;
  8641. case kDeclaration_body: yWriteDeclaration_body (yyt); yyIndentSelector ("Const_or_routine"); yyt = yyt->Declaration_body.Const_or_routine; break;
  8642. case kConst_or_routine: (void) fputs (Tree_NodeName [kConst_or_routine], yyf); (void) fputc ('\n', yyf); goto yyExit;
  8643. case kConst_or_routine0: (void) fputs (Tree_NodeName [kConst_or_routine0], yyf); (void) fputc ('\n', yyf); goto yyExit;
  8644. case kM_const: yWriteM_const (yyt); yyIndentSelector ("Manifest_constant"); yyt = yyt->M_const.Manifest_constant; break;
  8645. case kUnique: yWriteUnique (yyt); goto yyExit;
  8646. case kRoutine: yWriteRoutine (yyt); yyIndentSelector ("Rescue"); yyt = yyt->Routine.Rescue; break;
  8647. case kParent_list: (void) fputs (Tree_NodeName [kParent_list], yyf); (void) fputc ('\n', yyf); goto yyExit;
  8648. case kParent_list0: (void) fputs (Tree_NodeName [kParent_list0], yyf); (void) fputc ('\n', yyf); goto yyExit;
  8649. case kParent_list1: yWriteParent_list1 (yyt); yyIndentSelector ("Parent_list"); yyt = yyt->Parent_list1.Parent_list; break;
  8650. case kParent: yWriteParent (yyt); yyIndentSelector ("Feature_adaptation"); yyt = yyt->Parent.Feature_adaptation; break;
  8651. case kFeature_adaptation: (void) fputs (Tree_NodeName [kFeature_adaptation], yyf); (void) fputc ('\n', yyf); goto yyExit;
  8652. case kFeature_adaptation0: (void) fputs (Tree_NodeName [kFeature_adaptation0], yyf); (void) fputc ('\n', yyf); goto yyExit;
  8653. case kFeature_adaptation1: yWriteFeature_adaptation1 (yyt); yyIndentSelector ("Select"); yyt = yyt->Feature_adaptation1.Select; break;
  8654. case kRename_list: (void) fputs (Tree_NodeName [kRename_list], yyf); (void) fputc ('\n', yyf); goto yyExit;
  8655. case kRename_list0: (void) fputs (Tree_NodeName [kRename_list0], yyf); (void) fputc ('\n', yyf); goto yyExit;
  8656. case kRename_list1: yWriteRename_list1 (yyt); yyIndentSelector ("Rename_list"); yyt = yyt->Rename_list1.Rename_list; break;
  8657. case kRename_pair: yWriteRename_pair (yyt); yyIndentSelector ("Name2"); yyt = yyt->Rename_pair.Name2; break;
  8658. case kCreators: (void) fputs (Tree_NodeName [kCreators], yyf); (void) fputc ('\n', yyf); goto yyExit;
  8659. case kCreators0: (void) fputs (Tree_NodeName [kCreators0], yyf); (void) fputc ('\n', yyf); goto yyExit;
  8660. case kCreators1: yWriteCreators1 (yyt); yyIndentSelector ("Creators"); yyt = yyt->Creators1.Creators; break;
  8661. case kCreation_clause: yWriteCreation_clause (yyt); yyIndentSelector ("Feature_list"); yyt = yyt->Creation_clause.Feature_list; break;
  8662. case kNew_feature_list: (void) fputs (Tree_NodeName [kNew_feature_list], yyf); (void) fputc ('\n', yyf); goto yyExit;
  8663. case kNew_feature_list0: (void) fputs (Tree_NodeName [kNew_feature_list0], yyf); (void) fputc ('\n', yyf); goto yyExit;
  8664. case kNew_feature_list1: yWriteNew_feature_list1 (yyt); yyIndentSelector ("New_feature_list"); yyt = yyt->New_feature_list1.New_feature_list; break;
  8665. case kFeature_name: (void) fputs (Tree_NodeName [kFeature_name], yyf); (void) fputc ('\n', yyf); goto yyExit;
  8666. case kFrozen: yWriteFrozen (yyt); yyIndentSelector ("Feature_name"); yyt = yyt->Frozen.Feature_name; break;
  8667. case kIdent_name: yWriteIdent_name (yyt); yyIndentSelector ("Id"); yyt = yyt->Ident_name.Id; break;
  8668. case kOp: (void) fputs (Tree_NodeName [kOp], yyf); (void) fputc ('\n', yyf); goto yyExit;
  8669. case kPrefix: yWritePrefix (yyt); yyIndentSelector ("Op_name"); yyt = yyt->Prefix.Op_name; break;
  8670. case kInfix: yWriteInfix (yyt); yyIndentSelector ("Op_name"); yyt = yyt->Infix.Op_name; break;
  8671. case kOp_name: yWriteOp_name (yyt); goto yyExit;
  8672. case kFree_op: yWriteFree_op (yyt); goto yyExit;
  8673. case kOper: yWriteOper (yyt); goto yyExit;
  8674. case kNew_export_list: (void) fputs (Tree_NodeName [kNew_export_list], yyf); (void) fputc ('\n', yyf); goto yyExit;
  8675. case kNew_export_list0: (void) fputs (Tree_NodeName [kNew_export_list0], yyf); (void) fputc ('\n', yyf); goto yyExit;
  8676. case kNew_export_list1: yWriteNew_export_list1 (yyt); yyIndentSelector ("New_export_list"); yyt = yyt->New_export_list1.New_export_list; break;
  8677. case kNew_export_item: yWriteNew_export_item (yyt); yyIndentSelector ("Feature_set"); yyt = yyt->New_export_item.Feature_set; break;
  8678. case kFeature_list: (void) fputs (Tree_NodeName [kFeature_list], yyf); (void) fputc ('\n', yyf); goto yyExit;
  8679. case kAll: (void) fputs (Tree_NodeName [kAll], yyf); (void) fputc ('\n', yyf); goto yyExit;
  8680. case kFeature_list0: (void) fputs (Tree_NodeName [kFeature_list0], yyf); (void) fputc ('\n', yyf); goto yyExit;
  8681. case kFeature_list1: yWriteFeature_list1 (yyt); yyIndentSelector ("Feature_list"); yyt = yyt->Feature_list1.Feature_list; break;
  8682. case kFormal_args: (void) fputs (Tree_NodeName [kFormal_args], yyf); (void) fputc ('\n', yyf); goto yyExit;
  8683. case kFormal_args0: (void) fputs (Tree_NodeName [kFormal_args0], yyf); (void) fputc ('\n', yyf); goto yyExit;
  8684. case kFormal_args1: yWriteFormal_args1 (yyt); yyIndentSelector ("Formal_args"); yyt = yyt->Formal_args1.Formal_args; break;
  8685. case kRoutine_body: (void) fputs (Tree_NodeName [kRoutine_body], yyf); (void) fputc ('\n', yyf); goto yyExit;
  8686. case kRoutine_body0: (void) fputs (Tree_NodeName [kRoutine_body0], yyf); (void) fputc ('\n', yyf); goto yyExit;
  8687. case kEffective: (void) fputs (Tree_NodeName [kEffective], yyf); (void) fputc ('\n', yyf); goto yyExit;
  8688. case kInternal: (void) fputs (Tree_NodeName [kInternal], yyf); (void) fputc ('\n', yyf); goto yyExit;
  8689. case kDo_body: yWriteDo_body (yyt); yyIndentSelector ("Compound"); yyt = yyt->Do_body.Compound; break;
  8690. case kOnce_body: yWriteOnce_body (yyt); yyIndentSelector ("Compound"); yyt = yyt->Once_body.Compound; break;
  8691. case kExternal: yWriteExternal (yyt); yyIndentSelector ("Lang2"); yyt = yyt->External.Lang2; break;
  8692. case kDeferred: yWriteDeferred (yyt); goto yyExit;
  8693. case kEntity_decl_group: yWriteEntity_decl_group (yyt); yyIndentSelector ("Type_mark"); yyt = yyt->Entity_decl_group.Type_mark; break;
  8694. case kFormal_generics: (void) fputs (Tree_NodeName [kFormal_generics], yyf); (void) fputc ('\n', yyf); goto yyExit;
  8695. case kFormal_generics0: (void) fputs (Tree_NodeName [kFormal_generics0], yyf); (void) fputc ('\n', yyf); goto yyExit;
  8696. case kFormal_generics1: yWriteFormal_generics1 (yyt); yyIndentSelector ("Formal_generics"); yyt = yyt->Formal_generics1.Formal_generics; break;
  8697. case kFormal_generic: yWriteFormal_generic (yyt); yyIndentSelector ("Constraint"); yyt = yyt->Formal_generic.Constraint; break;
  8698. case kConstraint: (void) fputs (Tree_NodeName [kConstraint], yyf); (void) fputc ('\n', yyf); goto yyExit;
  8699. case kConstraint0: (void) fputs (Tree_NodeName [kConstraint0], yyf); (void) fputc ('\n', yyf); goto yyExit;
  8700. case kConstraint1: yWriteConstraint1 (yyt); yyIndentSelector ("Class_type"); yyt = yyt->Constraint1.Class_type; break;
  8701. case kCompound: (void) fputs (Tree_NodeName [kCompound], yyf); (void) fputc ('\n', yyf); goto yyExit;
  8702. case kCompound0: (void) fputs (Tree_NodeName [kCompound0], yyf); (void) fputc ('\n', yyf); goto yyExit;
  8703. case kCompound1: yWriteCompound1 (yyt); yyIndentSelector ("Compound"); yyt = yyt->Compound1.Compound; break;
  8704. case kThen_part_list: (void) fputs (Tree_NodeName [kThen_part_list], yyf); (void) fputc ('\n', yyf); goto yyExit;
  8705. case kThen_part_list0: (void) fputs (Tree_NodeName [kThen_part_list0], yyf); (void) fputc ('\n', yyf); goto yyExit;
  8706. case kThen_part_list1: yWriteThen_part_list1 (yyt); yyIndentSelector ("Then_part_list"); yyt = yyt->Then_part_list1.Then_part_list; break;
  8707. case kThen_part: yWriteThen_part (yyt); yyIndentSelector ("Compound"); yyt = yyt->Then_part.Compound; break;
  8708. case kWhen_part_list: (void) fputs (Tree_NodeName [kWhen_part_list], yyf); (void) fputc ('\n', yyf); goto yyExit;
  8709. case kWhen_part_list0: (void) fputs (Tree_NodeName [kWhen_part_list0], yyf); (void) fputc ('\n', yyf); goto yyExit;
  8710. case kWhen_part_list1: yWriteWhen_part_list1 (yyt); yyIndentSelector ("When_part_list"); yyt = yyt->When_part_list1.When_part_list; break;
  8711. case kWhen_part: yWriteWhen_part (yyt); yyIndentSelector ("Compound"); yyt = yyt->When_part.Compound; break;
  8712. case kChoices: (void) fputs (Tree_NodeName [kChoices], yyf); (void) fputc ('\n', yyf); goto yyExit;
  8713. case kChoices0: (void) fputs (Tree_NodeName [kChoices0], yyf); (void) fputc ('\n', yyf); goto yyExit;
  8714. case kChoices1: yWriteChoices1 (yyt); yyIndentSelector ("Choices"); yyt = yyt->Choices1.Choices; break;
  8715. case kChoice: (void) fputs (Tree_NodeName [kChoice], yyf); (void) fputc ('\n', yyf); goto yyExit;
  8716. case kInterval: yWriteInterval (yyt); yyIndentSelector ("To"); yyt = yyt->Interval.To; break;
  8717. case kVal: yWriteVal (yyt); yyIndentSelector ("Manifest_constant"); yyt = yyt->Val.Manifest_constant; break;
  8718. case kInstruction: (void) fputs (Tree_NodeName [kInstruction], yyf); (void) fputc ('\n', yyf); goto yyExit;
  8719. case kInstruction0: (void) fputs (Tree_NodeName [kInstruction0], yyf); (void) fputc ('\n', yyf); goto yyExit;
  8720. case kCreation: yWriteCreation (yyt); yyIndentSelector ("Unqual_call"); yyt = yyt->Creation.Unqual_call; break;
  8721. case kCall_instruct: yWriteCall_instruct (yyt); yyIndentSelector ("Call"); yyt = yyt->Call_instruct.Call; break;
  8722. case kAssign: yWriteAssign (yyt); yyIndentSelector ("Expression"); yyt = yyt->Assign.Expression; break;
  8723. case kRev_assign: yWriteRev_assign (yyt); yyIndentSelector ("Expression"); yyt = yyt->Rev_assign.Expression; break;
  8724. case kConditional: yWriteConditional (yyt); yyIndentSelector ("Else_part"); yyt = yyt->Conditional.Else_part; break;
  8725. case kMulti_branch: yWriteMulti_branch (yyt); yyIndentSelector ("Else_part"); yyt = yyt->Multi_branch.Else_part; break;
  8726. case kLoop: yWriteLoop (yyt); yyIndentSelector ("Loop_body"); yyt = yyt->Loop.Loop_body; break;
  8727. case kCheck: yWriteCheck (yyt); yyIndentSelector ("Assertion"); yyt = yyt->Check.Assertion; break;
  8728. case kDebug: yWriteDebug (yyt); yyIndentSelector ("Compound"); yyt = yyt->Debug.Compound; break;
  8729. case kRetry: yWriteRetry (yyt); goto yyExit;
  8730. case kLoop_body: (void) fputs (Tree_NodeName [kLoop_body], yyf); (void) fputc ('\n', yyf); goto yyExit;
  8731. case kLoop_body0: (void) fputs (Tree_NodeName [kLoop_body0], yyf); (void) fputc ('\n', yyf); goto yyExit;
  8732. case kLoop_body1: yWriteLoop_body1 (yyt); yyIndentSelector ("Compound"); yyt = yyt->Loop_body1.Compound; break;
  8733. case kType: (void) fputs (Tree_NodeName [kType], yyf); (void) fputc ('\n', yyf); goto yyExit;
  8734. case kType0: (void) fputs (Tree_NodeName [kType0], yyf); (void) fputc ('\n', yyf); goto yyExit;
  8735. case kClass_type: yWriteClass_type (yyt); yyIndentSelector ("Actual_generics"); yyt = yyt->Class_type.Actual_generics; break;
  8736. case kClass_type_expanded: yWriteClass_type_expanded (yyt); yyIndentSelector ("Actual_generics"); yyt = yyt->Class_type_expanded.Actual_generics; break;
  8737. case kBit_type: yWriteBit_type (yyt); yyIndentSelector ("Manifest_constant"); yyt = yyt->Bit_type.Manifest_constant; break;
  8738. case kSimple_type: yWriteSimple_type (yyt); yyIndentSelector ("Manifest_constant"); yyt = yyt->Simple_type.Manifest_constant; break;
  8739. case kAnchored: yWriteAnchored (yyt); yyIndentSelector ("Entity"); yyt = yyt->Anchored.Entity; break;
  8740. case kActual_generics: (void) fputs (Tree_NodeName [kActual_generics], yyf); (void) fputc ('\n', yyf); goto yyExit;
  8741. case kActual_generics0: (void) fputs (Tree_NodeName [kActual_generics0], yyf); (void) fputc ('\n', yyf); goto yyExit;
  8742. case kActual_generics1: yWriteActual_generics1 (yyt); yyIndentSelector ("Type_list"); yyt = yyt->Actual_generics1.Type_list; break;
  8743. case kCondition: (void) fputs (Tree_NodeName [kCondition], yyf); (void) fputc ('\n', yyf); goto yyExit;
  8744. case kCondition0: (void) fputs (Tree_NodeName [kCondition0], yyf); (void) fputc ('\n', yyf); goto yyExit;
  8745. case kCondition1: yWriteCondition1 (yyt); yyIndentSelector ("Assertion"); yyt = yyt->Condition1.Assertion; break;
  8746. case kAssertion: (void) fputs (Tree_NodeName [kAssertion], yyf); (void) fputc ('\n', yyf); goto yyExit;
  8747. case kAssertion0: (void) fputs (Tree_NodeName [kAssertion0], yyf); (void) fputc ('\n', yyf); goto yyExit;
  8748. case kAssertion1: yWriteAssertion1 (yyt); yyIndentSelector ("Assertion"); yyt = yyt->Assertion1.Assertion; break;
  8749. case kAssertion_clause: (void) fputs (Tree_NodeName [kAssertion_clause], yyf); (void) fputc ('\n', yyf); goto yyExit;
  8750. case kAssertion_clause0: (void) fputs (Tree_NodeName [kAssertion_clause0], yyf); (void) fputc ('\n', yyf); goto yyExit;
  8751. case kAssertion_clause1: yWriteAssertion_clause1 (yyt); yyIndentSelector ("Expression"); yyt = yyt->Assertion_clause1.Expression; break;
  8752. case kType_list: (void) fputs (Tree_NodeName [kType_list], yyf); (void) fputc ('\n', yyf); goto yyExit;
  8753. case kType_list0: (void) fputs (Tree_NodeName [kType_list0], yyf); (void) fputc ('\n', yyf); goto yyExit;
  8754. case kType_list1: yWriteType_list1 (yyt); yyIndentSelector ("Type_list"); yyt = yyt->Type_list1.Type_list; break;
  8755. case kCall_chain: (void) fputs (Tree_NodeName [kCall_chain], yyf); (void) fputc ('\n', yyf); goto yyExit;
  8756. case kCall_chain0: (void) fputs (Tree_NodeName [kCall_chain0], yyf); (void) fputc ('\n', yyf); goto yyExit;
  8757. case kCall_chain1: yWriteCall_chain1 (yyt); yyIndentSelector ("Call_chain"); yyt = yyt->Call_chain1.Call_chain; break;
  8758. case kUnqual_call: (void) fputs (Tree_NodeName [kUnqual_call], yyf); (void) fputc ('\n', yyf); goto yyExit;
  8759. case kUnqual_call0: (void) fputs (Tree_NodeName [kUnqual_call0], yyf); (void) fputc ('\n', yyf); goto yyExit;
  8760. case kUnqual_call1: yWriteUnqual_call1 (yyt); yyIndentSelector ("Actuals"); yyt = yyt->Unqual_call1.Actuals; break;
  8761. case kActuals: (void) fputs (Tree_NodeName [kActuals], yyf); (void) fputc ('\n', yyf); goto yyExit;
  8762. case kActuals0: (void) fputs (Tree_NodeName [kActuals0], yyf); (void) fputc ('\n', yyf); goto yyExit;
  8763. case kActuals1: yWriteActuals1 (yyt); yyIndentSelector ("Actual_list"); yyt = yyt->Actuals1.Actual_list; break;
  8764. case kActual_list: (void) fputs (Tree_NodeName [kActual_list], yyf); (void) fputc ('\n', yyf); goto yyExit;
  8765. case kActual_list0: (void) fputs (Tree_NodeName [kActual_list0], yyf); (void) fputc ('\n', yyf); goto yyExit;
  8766. case kActual_list1: yWriteActual_list1 (yyt); yyIndentSelector ("Actual_list"); yyt = yyt->Actual_list1.Actual_list; break;
  8767. case kActual: (void) fputs (Tree_NodeName [kActual], yyf); (void) fputc ('\n', yyf); goto yyExit;
  8768. case kAddr: yWriteAddr (yyt); yyIndentSelector ("Entity"); yyt = yyt->Addr.Entity; break;
  8769. case kExpression: (void) fputs (Tree_NodeName [kExpression], yyf); (void) fputc ('\n', yyf); goto yyExit;
  8770. case kExpression0: (void) fputs (Tree_NodeName [kExpression0], yyf); (void) fputc ('\n', yyf); goto yyExit;
  8771. case kComment: yWriteComment (yyt); goto yyExit;
  8772. case kSimple_expr: yWriteSimple_expr (yyt); yyIndentSelector ("Manifest_constant"); yyt = yyt->Simple_expr.Manifest_constant; break;
  8773. case kCall: yWriteCall (yyt); yyIndentSelector ("Call_chain"); yyt = yyt->Call.Call_chain; break;
  8774. case kBin_expr: yWriteBin_expr (yyt); yyIndentSelector ("Rop"); yyt = yyt->Bin_expr.Rop; break;
  8775. case kUn_expr: yWriteUn_expr (yyt); yyIndentSelector ("Expression"); yyt = yyt->Un_expr.Expression; break;
  8776. case kParenth: yWriteParenth (yyt); yyIndentSelector ("Expression"); yyt = yyt->Parenth.Expression; break;
  8777. case kManifest_array: (void) fputs (Tree_NodeName [kManifest_array], yyf); (void) fputc ('\n', yyf); goto yyExit;
  8778. case kManifest_array0: (void) fputs (Tree_NodeName [kManifest_array0], yyf); (void) fputc ('\n', yyf); goto yyExit;
  8779. case kManifest_array1: yWriteManifest_array1 (yyt); yyIndentSelector ("Manifest_array"); yyt = yyt->Manifest_array1.Manifest_array; break;
  8780. case kOld: yWriteOld (yyt); yyIndentSelector ("Expression"); yyt = yyt->Old.Expression; break;
  8781. case kStrip: yWriteStrip (yyt); yyIndentSelector ("List"); yyt = yyt->Strip.List; break;
  8782. case kList: (void) fputs (Tree_NodeName [kList], yyf); (void) fputc ('\n', yyf); goto yyExit;
  8783. case knolist: (void) fputs (Tree_NodeName [knolist], yyf); (void) fputc ('\n', yyf); goto yyExit;
  8784. case klist: yWritelist (yyt); yyIndentSelector ("List"); yyt = yyt->list.List; break;
  8785. case kManifest_constant: (void) fputs (Tree_NodeName [kManifest_constant], yyf); (void) fputc ('\n', yyf); goto yyExit;
  8786. case kManifest_constant0: (void) fputs (Tree_NodeName [kManifest_constant0], yyf); (void) fputc ('\n', yyf); goto yyExit;
  8787. case kCh: yWriteCh (yyt); goto yyExit;
  8788. case kTrue: yWriteTrue (yyt); goto yyExit;
  8789. case kFalse: yWriteFalse (yyt); goto yyExit;
  8790. case kInt: yWriteInt (yyt); yyIndentSelector ("Sign"); yyt = yyt->Int.Sign; break;
  8791. case kReal: yWriteReal (yyt); yyIndentSelector ("Sign"); yyt = yyt->Real.Sign; break;
  8792. case k_CHARACTER: yWrite_CHARACTER (yyt); goto yyExit;
  8793. case k_INTEGER: yWrite_INTEGER (yyt); goto yyExit;
  8794. case k_REAL: yWrite_REAL (yyt); goto yyExit;
  8795. case k_DOUBLE: yWrite_DOUBLE (yyt); goto yyExit;
  8796. case k_BOOLEAN: yWrite_BOOLEAN (yyt); goto yyExit;
  8797. case k_STRING: yWrite_STRING (yyt); goto yyExit;
  8798. case k_BIT: yWrite_BIT (yyt); goto yyExit;
  8799. case k_NONE: yWrite_NONE (yyt); goto yyExit;
  8800. case kBitseq: yWriteBitseq (yyt); goto yyExit;
  8801. case kString: yWriteString (yyt); goto yyExit;
  8802. case kString0: (void) fputs (Tree_NodeName [kString0], yyf); (void) fputc ('\n', yyf); goto yyExit;
  8803. case kEntity: (void) fputs (Tree_NodeName [kEntity], yyf); (void) fputc ('\n', yyf); goto yyExit;
  8804. case kEntity0: (void) fputs (Tree_NodeName [kEntity0], yyf); (void) fputc ('\n', yyf); goto yyExit;
  8805. case kCurrent: yWriteCurrent (yyt); goto yyExit;
  8806. case kResult: yWriteResult (yyt); goto yyExit;
  8807. case kId: yWriteId (yyt); goto yyExit;
  8808.   default: goto yyExit;
  8809.   }
  8810.  }
  8811. yyExit:
  8812.  yyIndentLevel = yyLevel;
  8813. }
  8814.  
  8815. static tIdent yyKindToIdent [192 + 1];
  8816. static bool yyIsInitialized = false;
  8817.  
  8818. static short yyMapToKind
  8819. # if defined __STDC__ | defined __cplusplus
  8820.  (char * yys)
  8821. # else
  8822.  (yys) char * yys;
  8823. # endif
  8824. {
  8825.  register int yyk;
  8826.  register tIdent yyi = MakeIdent ((tString) yys, strlen (yys));
  8827.  for (yyk = 0; yyk <= 192; yyk ++) {
  8828.   if (yyKindToIdent [yyk] == yyi) return yyk;
  8829.  }
  8830.  return 0;
  8831. }
  8832.  
  8833. static void yyReadNl () { (void) fscanf (yyf, "\n"); }
  8834.  
  8835. static tIdent yyReadIdent ()
  8836. {
  8837.  char yys [256];
  8838.  (void) fscanf (yyf, "%s", yys);
  8839.  return MakeIdent ((tString) yys, strlen (yys));
  8840. }
  8841.  
  8842. static void yyReadHex
  8843. # if defined __STDC__ | defined __cplusplus
  8844.  (unsigned char * yyx, int yysize)
  8845. # else
  8846.  (yyx, yysize) unsigned char * yyx; int yysize;
  8847. # endif
  8848. {
  8849.  register int yyi; int yyk;
  8850.  for (yyi = 0; yyi < yysize; yyi ++) { (void) fscanf (yyf, "%x ", & yyk); yyx [yyi] = yyk; }
  8851. }
  8852.  
  8853. static void yySkip () { (void) fscanf (yyf, " %*s =%*c"); }
  8854.  
  8855. static void yyReadTree
  8856. # if defined __STDC__ | defined __cplusplus
  8857.  (yyPtrtTree yyt)
  8858. # else
  8859.  (yyt) yyPtrtTree yyt;
  8860. # endif
  8861. {
  8862.  static Tree_tLabel yyLabel;
  8863.  static Tree_tKind yyKind;
  8864.  static char yys [256];
  8865.  for (;;) {
  8866.   switch (getc (yyf)) {
  8867.   case '^': (void) fscanf (yyf, "%hd\n", & yyLabel); * yyt = yyMapToTree (yyLabel); return;
  8868.   case '\n': case '0': (void) fscanf (yyf, "%hd%*c %s\n", & yyLabel, yys);
  8869.    yyKind = yyMapToKind (yys); * yyt = MakeTree (yyKind);
  8870.    if (yyLabel != yyMapToLabel (* yyt)) { (void) fputs ("Tree: error in ReadTree\n", stderr); Tree_Exit (); } break;
  8871.   default: ;
  8872.    (void) fscanf (yyf, "%s", yys);
  8873.    yyKind = yyMapToKind (yys);
  8874.    if (yyKind == 0) { * yyt = NoTree; return; }
  8875.    * yyt = MakeTree (yyKind);
  8876.   }
  8877.  
  8878.   switch (yyKind) {
  8879. case kEiffel:
  8880. yySkip (); yyt = & ((* yyt)->Eiffel.Classes); break;
  8881. case kClasses1:
  8882. yySkip (); readtTree (& ((* yyt)->Classes1.Class_declaration))
  8883. yySkip (); yyt = & ((* yyt)->Classes1.Classes); break;
  8884. case kClass_declaration:
  8885. yySkip (); readtTree (& ((* yyt)->Class_declaration.Indexing))
  8886. yySkip (); readtTree (& ((* yyt)->Class_declaration.Class_header))
  8887. yySkip (); readtTree (& ((* yyt)->Class_declaration.Formal_generics))
  8888. yySkip (); readtTree (& ((* yyt)->Class_declaration.Obsolete))
  8889. yySkip (); readtTree (& ((* yyt)->Class_declaration.Inheritance))
  8890. yySkip (); readtTree (& ((* yyt)->Class_declaration.Creators))
  8891. yySkip (); readtTree (& ((* yyt)->Class_declaration.Features))
  8892. yySkip (); readtStringRef ((* yyt)->Class_declaration.comment) yyReadNl ();
  8893. yySkip (); yyt = & ((* yyt)->Class_declaration.Invariant); break;
  8894. case kIndex_list1:
  8895. yySkip (); readtTree (& ((* yyt)->Index_list1.Index_clause))
  8896. yySkip (); yyt = & ((* yyt)->Index_list1.Index_list); break;
  8897. case kIndex_clause:
  8898. yySkip (); readtTree (& ((* yyt)->Index_clause.Index))
  8899. yySkip (); yyt = & ((* yyt)->Index_clause.Index_terms); break;
  8900. case kClass:
  8901. yySkip (); yyt = & ((* yyt)->Class.Name); break;
  8902. case kExpanded_class:
  8903. yySkip (); yyt = & ((* yyt)->Expanded_class.Name); break;
  8904. case kDeferred_class:
  8905. yySkip (); yyt = & ((* yyt)->Deferred_class.Name); break;
  8906. case kFeatures1:
  8907. yySkip (); readtTree (& ((* yyt)->Features1.Feature_clause))
  8908. yySkip (); yyt = & ((* yyt)->Features1.Features); break;
  8909. case kFeature_clause:
  8910. yySkip (); readtTree (& ((* yyt)->Feature_clause.Clients))
  8911. yySkip (); readtStringRef ((* yyt)->Feature_clause.comment) yyReadNl ();
  8912. yySkip (); yyt = & ((* yyt)->Feature_clause.Feature_decls); break;
  8913. case kClients1:
  8914. yySkip (); yyt = & ((* yyt)->Clients1.List); break;
  8915. case kFeature_decls1:
  8916. yySkip (); readtTree (& ((* yyt)->Feature_decls1.Feature_decl))
  8917. yySkip (); yyt = & ((* yyt)->Feature_decls1.Feature_decls); break;
  8918. case kFeature_decl:
  8919. yySkip (); readtTree (& ((* yyt)->Feature_decl.New_feature_list))
  8920. yySkip (); yyt = & ((* yyt)->Feature_decl.Declaration_body); break;
  8921. case kDeclaration_body:
  8922. yySkip (); readtTree (& ((* yyt)->Declaration_body.Formal_args))
  8923. yySkip (); readtTree (& ((* yyt)->Declaration_body.Type_mark))
  8924. yySkip (); yyt = & ((* yyt)->Declaration_body.Const_or_routine); break;
  8925. case kM_const:
  8926. yySkip (); yyt = & ((* yyt)->M_const.Manifest_constant); break;
  8927. case kUnique:
  8928. yySkip (); readtPosition ((* yyt)->Unique.pos) yyReadNl ();
  8929. return;
  8930. case kRoutine:
  8931. yySkip (); readtTree (& ((* yyt)->Routine.Obsolete))
  8932. yySkip (); readtStringRef ((* yyt)->Routine.comment) yyReadNl ();
  8933. yySkip (); readtTree (& ((* yyt)->Routine.Precondition))
  8934. yySkip (); readtTree (& ((* yyt)->Routine.Local_decls))
  8935. yySkip (); readtTree (& ((* yyt)->Routine.Routine_body))
  8936. yySkip (); readtTree (& ((* yyt)->Routine.Postcondition))
  8937. yySkip (); readtStringRef ((* yyt)->Routine.end_comment) yyReadNl ();
  8938. yySkip (); yyt = & ((* yyt)->Routine.Rescue); break;
  8939. case kParent_list1:
  8940. yySkip (); readtTree (& ((* yyt)->Parent_list1.Parent))
  8941. yySkip (); yyt = & ((* yyt)->Parent_list1.Parent_list); break;
  8942. case kParent:
  8943. yySkip (); readtTree (& ((* yyt)->Parent.Class_type))
  8944. yySkip (); yyt = & ((* yyt)->Parent.Feature_adaptation); break;
  8945. case kFeature_adaptation1:
  8946. yySkip (); readtTree (& ((* yyt)->Feature_adaptation1.Rename))
  8947. yySkip (); readtTree (& ((* yyt)->Feature_adaptation1.New_export))
  8948. yySkip (); readtTree (& ((* yyt)->Feature_adaptation1.Undefine))
  8949. yySkip (); readtTree (& ((* yyt)->Feature_adaptation1.Redefine))
  8950. yySkip (); yyt = & ((* yyt)->Feature_adaptation1.Select); break;
  8951. case kRename_list1:
  8952. yySkip (); readtTree (& ((* yyt)->Rename_list1.Rename_pair))
  8953. yySkip (); yyt = & ((* yyt)->Rename_list1.Rename_list); break;
  8954. case kRename_pair:
  8955. yySkip (); readtTree (& ((* yyt)->Rename_pair.Name1))
  8956. yySkip (); yyt = & ((* yyt)->Rename_pair.Name2); break;
  8957. case kCreators1:
  8958. yySkip (); readtTree (& ((* yyt)->Creators1.Creation_clause))
  8959. yySkip (); yyt = & ((* yyt)->Creators1.Creators); break;
  8960. case kCreation_clause:
  8961. yySkip (); readtTree (& ((* yyt)->Creation_clause.Clients))
  8962. yySkip (); readtStringRef ((* yyt)->Creation_clause.comment) yyReadNl ();
  8963. yySkip (); yyt = & ((* yyt)->Creation_clause.Feature_list); break;
  8964. case kNew_feature_list1:
  8965. yySkip (); readtTree (& ((* yyt)->New_feature_list1.Feature_name))
  8966. yySkip (); yyt = & ((* yyt)->New_feature_list1.New_feature_list); break;
  8967. case kFrozen:
  8968. yySkip (); yyt = & ((* yyt)->Frozen.Feature_name); break;
  8969. case kIdent_name:
  8970. yySkip (); yyt = & ((* yyt)->Ident_name.Id); break;
  8971. case kPrefix:
  8972. yySkip (); yyt = & ((* yyt)->Prefix.Op_name); break;
  8973. case kInfix:
  8974. yySkip (); yyt = & ((* yyt)->Infix.Op_name); break;
  8975. case kOp_name:
  8976. yySkip (); readtPosition ((* yyt)->Op_name.pos) yyReadNl ();
  8977. return;
  8978. case kFree_op:
  8979. yySkip (); readtPosition ((* yyt)->Free_op.pos) yyReadNl ();
  8980. yySkip (); readtIdent ((* yyt)->Free_op.ident) yyReadNl ();
  8981. return;
  8982. case kOper:
  8983. yySkip (); readtPosition ((* yyt)->Oper.pos) yyReadNl ();
  8984. yySkip (); readint ((* yyt)->Oper.op) yyReadNl ();
  8985. return;
  8986. case kNew_export_list1:
  8987. yySkip (); readtTree (& ((* yyt)->New_export_list1.New_export_item))
  8988. yySkip (); yyt = & ((* yyt)->New_export_list1.New_export_list); break;
  8989. case kNew_export_item:
  8990. yySkip (); readtTree (& ((* yyt)->New_export_item.Clients))
  8991. yySkip (); yyt = & ((* yyt)->New_export_item.Feature_set); break;
  8992. case kFeature_list1:
  8993. yySkip (); readtTree (& ((* yyt)->Feature_list1.Feature_name))
  8994. yySkip (); yyt = & ((* yyt)->Feature_list1.Feature_list); break;
  8995. case kFormal_args1:
  8996. yySkip (); readtTree (& ((* yyt)->Formal_args1.Entity_decl_group))
  8997. yySkip (); yyt = & ((* yyt)->Formal_args1.Formal_args); break;
  8998. case kDo_body:
  8999. yySkip (); yyt = & ((* yyt)->Do_body.Compound); break;
  9000. case kOnce_body:
  9001. yySkip (); yyt = & ((* yyt)->Once_body.Compound); break;
  9002. case kExternal:
  9003. yySkip (); readtTree (& ((* yyt)->External.Lang1))
  9004. yySkip (); yyt = & ((* yyt)->External.Lang2); break;
  9005. case kDeferred:
  9006. yySkip (); readtPosition ((* yyt)->Deferred.pos) yyReadNl ();
  9007. return;
  9008. case kEntity_decl_group:
  9009. yySkip (); readtTree (& ((* yyt)->Entity_decl_group.Id_list))
  9010. yySkip (); yyt = & ((* yyt)->Entity_decl_group.Type_mark); break;
  9011. case kFormal_generics1:
  9012. yySkip (); readtTree (& ((* yyt)->Formal_generics1.Formal_generic))
  9013. yySkip (); yyt = & ((* yyt)->Formal_generics1.Formal_generics); break;
  9014. case kFormal_generic:
  9015. yySkip (); readtTree (& ((* yyt)->Formal_generic.Id))
  9016. yySkip (); yyt = & ((* yyt)->Formal_generic.Constraint); break;
  9017. case kConstraint1:
  9018. yySkip (); yyt = & ((* yyt)->Constraint1.Class_type); break;
  9019. case kCompound1:
  9020. yySkip (); readtTree (& ((* yyt)->Compound1.Instruction))
  9021. yySkip (); yyt = & ((* yyt)->Compound1.Compound); break;
  9022. case kThen_part_list1:
  9023. yySkip (); readtTree (& ((* yyt)->Then_part_list1.Then_part))
  9024. yySkip (); yyt = & ((* yyt)->Then_part_list1.Then_part_list); break;
  9025. case kThen_part:
  9026. yySkip (); readtTree (& ((* yyt)->Then_part.Guard))
  9027. yySkip (); yyt = & ((* yyt)->Then_part.Compound); break;
  9028. case kWhen_part_list1:
  9029. yySkip (); readtTree (& ((* yyt)->When_part_list1.When_part))
  9030. yySkip (); yyt = & ((* yyt)->When_part_list1.When_part_list); break;
  9031. case kWhen_part:
  9032. yySkip (); readtTree (& ((* yyt)->When_part.Choices))
  9033. yySkip (); yyt = & ((* yyt)->When_part.Compound); break;
  9034. case kChoices1:
  9035. yySkip (); readtTree (& ((* yyt)->Choices1.Choice))
  9036. yySkip (); yyt = & ((* yyt)->Choices1.Choices); break;
  9037. case kInterval:
  9038. yySkip (); readtTree (& ((* yyt)->Interval.From))
  9039. yySkip (); yyt = & ((* yyt)->Interval.To); break;
  9040. case kVal:
  9041. yySkip (); yyt = & ((* yyt)->Val.Manifest_constant); break;
  9042. case kCreation:
  9043. yySkip (); readtTree (& ((* yyt)->Creation.Type))
  9044. yySkip (); readtTree (& ((* yyt)->Creation.Entity))
  9045. yySkip (); yyt = & ((* yyt)->Creation.Unqual_call); break;
  9046. case kCall_instruct:
  9047. yySkip (); yyt = & ((* yyt)->Call_instruct.Call); break;
  9048. case kAssign:
  9049. yySkip (); readtTree (& ((* yyt)->Assign.Addr))
  9050. yySkip (); yyt = & ((* yyt)->Assign.Expression); break;
  9051. case kRev_assign:
  9052. yySkip (); readtTree (& ((* yyt)->Rev_assign.Addr))
  9053. yySkip (); yyt = & ((* yyt)->Rev_assign.Expression); break;
  9054. case kConditional:
  9055. yySkip (); readtTree (& ((* yyt)->Conditional.Then_part))
  9056. yySkip (); yyt = & ((* yyt)->Conditional.Else_part); break;
  9057. case kMulti_branch:
  9058. yySkip (); readtTree (& ((* yyt)->Multi_branch.Guard))
  9059. yySkip (); readtTree (& ((* yyt)->Multi_branch.When_part_list))
  9060. yySkip (); yyt = & ((* yyt)->Multi_branch.Else_part); break;
  9061. case kLoop:
  9062. yySkip (); readtTree (& ((* yyt)->Loop.Initialization))
  9063. yySkip (); readtTree (& ((* yyt)->Loop.Invariant))
  9064. yySkip (); readtTree (& ((* yyt)->Loop.Variant))
  9065. yySkip (); yyt = & ((* yyt)->Loop.Loop_body); break;
  9066. case kCheck:
  9067. yySkip (); yyt = & ((* yyt)->Check.Assertion); break;
  9068. case kDebug:
  9069. yySkip (); readtTree (& ((* yyt)->Debug.Debug_keys))
  9070. yySkip (); yyt = & ((* yyt)->Debug.Compound); break;
  9071. case kRetry:
  9072. yySkip (); readtPosition ((* yyt)->Retry.pos) yyReadNl ();
  9073. return;
  9074. case kLoop_body1:
  9075. yySkip (); readtTree (& ((* yyt)->Loop_body1.Exit))
  9076. yySkip (); yyt = & ((* yyt)->Loop_body1.Compound); break;
  9077. case kClass_type:
  9078. yySkip (); readtTree (& ((* yyt)->Class_type.Id))
  9079. yySkip (); yyt = & ((* yyt)->Class_type.Actual_generics); break;
  9080. case kClass_type_expanded:
  9081. yySkip (); readtTree (& ((* yyt)->Class_type_expanded.Id))
  9082. yySkip (); yyt = & ((* yyt)->Class_type_expanded.Actual_generics); break;
  9083. case kBit_type:
  9084. yySkip (); yyt = & ((* yyt)->Bit_type.Manifest_constant); break;
  9085. case kSimple_type:
  9086. yySkip (); yyt = & ((* yyt)->Simple_type.Manifest_constant); break;
  9087. case kAnchored:
  9088. yySkip (); yyt = & ((* yyt)->Anchored.Entity); break;
  9089. case kActual_generics1:
  9090. yySkip (); yyt = & ((* yyt)->Actual_generics1.Type_list); break;
  9091. case kCondition1:
  9092. yySkip (); readint ((* yyt)->Condition1.extension) yyReadNl ();
  9093. yySkip (); yyt = & ((* yyt)->Condition1.Assertion); break;
  9094. case kAssertion1:
  9095. yySkip (); readtTree (& ((* yyt)->Assertion1.Assertion_clause))
  9096. yySkip (); yyt = & ((* yyt)->Assertion1.Assertion); break;
  9097. case kAssertion_clause1:
  9098. yySkip (); readtTree (& ((* yyt)->Assertion_clause1.Tag))
  9099. yySkip (); yyt = & ((* yyt)->Assertion_clause1.Expression); break;
  9100. case kType_list1:
  9101. yySkip (); readtTree (& ((* yyt)->Type_list1.Type))
  9102. yySkip (); yyt = & ((* yyt)->Type_list1.Type_list); break;
  9103. case kCall_chain1:
  9104. yySkip (); readtTree (& ((* yyt)->Call_chain1.Unqual_call))
  9105. yySkip (); yyt = & ((* yyt)->Call_chain1.Call_chain); break;
  9106. case kUnqual_call1:
  9107. yySkip (); readtTree (& ((* yyt)->Unqual_call1.Entity))
  9108. yySkip (); yyt = & ((* yyt)->Unqual_call1.Actuals); break;
  9109. case kActuals1:
  9110. yySkip (); yyt = & ((* yyt)->Actuals1.Actual_list); break;
  9111. case kActual_list1:
  9112. yySkip (); readtTree (& ((* yyt)->Actual_list1.Actual))
  9113. yySkip (); yyt = & ((* yyt)->Actual_list1.Actual_list); break;
  9114. case kAddr:
  9115. yySkip (); yyt = & ((* yyt)->Addr.Entity); break;
  9116. case kComment:
  9117. yySkip (); readtStringRef ((* yyt)->Comment.comment) yyReadNl ();
  9118. return;
  9119. case kSimple_expr:
  9120. yySkip (); yyt = & ((* yyt)->Simple_expr.Manifest_constant); break;
  9121. case kCall:
  9122. yySkip (); readtTree (& ((* yyt)->Call.Qual))
  9123. yySkip (); yyt = & ((* yyt)->Call.Call_chain); break;
  9124. case kBin_expr:
  9125. yySkip (); readtTree (& ((* yyt)->Bin_expr.Lop))
  9126. yySkip (); readtTree (& ((* yyt)->Bin_expr.Op))
  9127. yySkip (); yyt = & ((* yyt)->Bin_expr.Rop); break;
  9128. case kUn_expr:
  9129. yySkip (); readtTree (& ((* yyt)->Un_expr.Op))
  9130. yySkip (); yyt = & ((* yyt)->Un_expr.Expression); break;
  9131. case kParenth:
  9132. yySkip (); yyt = & ((* yyt)->Parenth.Expression); break;
  9133. case kManifest_array1:
  9134. yySkip (); readtTree (& ((* yyt)->Manifest_array1.Expression))
  9135. yySkip (); yyt = & ((* yyt)->Manifest_array1.Manifest_array); break;
  9136. case kOld:
  9137. yySkip (); yyt = & ((* yyt)->Old.Expression); break;
  9138. case kStrip:
  9139. yySkip (); yyt = & ((* yyt)->Strip.List); break;
  9140. case klist:
  9141. yySkip (); readtTree (& ((* yyt)->list.Manifest_constant))
  9142. yySkip (); yyt = & ((* yyt)->list.List); break;
  9143. case kCh:
  9144. yySkip (); readint ((* yyt)->Ch.ch) yyReadNl ();
  9145. yySkip (); readtPosition ((* yyt)->Ch.pos) yyReadNl ();
  9146. return;
  9147. case kTrue:
  9148. yySkip (); readtPosition ((* yyt)->True.pos) yyReadNl ();
  9149. return;
  9150. case kFalse:
  9151. yySkip (); readtPosition ((* yyt)->False.pos) yyReadNl ();
  9152. return;
  9153. case kInt:
  9154. yySkip (); readlong ((* yyt)->Int.value) yyReadNl ();
  9155. yySkip (); readtPosition ((* yyt)->Int.pos) yyReadNl ();
  9156. yySkip (); yyt = & ((* yyt)->Int.Sign); break;
  9157. case kReal:
  9158. yySkip (); readdouble ((* yyt)->Real.value) yyReadNl ();
  9159. yySkip (); readtPosition ((* yyt)->Real.pos) yyReadNl ();
  9160. yySkip (); yyt = & ((* yyt)->Real.Sign); break;
  9161. case k_CHARACTER:
  9162. yySkip (); readtPosition ((* yyt)->_CHARACTER.pos) yyReadNl ();
  9163. return;
  9164. case k_INTEGER:
  9165. yySkip (); readtPosition ((* yyt)->_INTEGER.pos) yyReadNl ();
  9166. return;
  9167. case k_REAL:
  9168. yySkip (); readtPosition ((* yyt)->_REAL.pos) yyReadNl ();
  9169. return;
  9170. case k_DOUBLE:
  9171. yySkip (); readtPosition ((* yyt)->_DOUBLE.pos) yyReadNl ();
  9172. return;
  9173. case k_BOOLEAN:
  9174. yySkip (); readtPosition ((* yyt)->_BOOLEAN.pos) yyReadNl ();
  9175. return;
  9176. case k_STRING:
  9177. yySkip (); readtPosition ((* yyt)->_STRING.pos) yyReadNl ();
  9178. return;
  9179. case k_BIT:
  9180. yySkip (); readtPosition ((* yyt)->_BIT.pos) yyReadNl ();
  9181. return;
  9182. case k_NONE:
  9183. yySkip (); readtPosition ((* yyt)->_NONE.pos) yyReadNl ();
  9184. return;
  9185. case kBitseq:
  9186. yySkip (); readtStringRef ((* yyt)->Bitseq.literal) yyReadNl ();
  9187. yySkip (); readtPosition ((* yyt)->Bitseq.pos) yyReadNl ();
  9188. return;
  9189. case kString:
  9190. yySkip (); readtStringRef ((* yyt)->String.string) yyReadNl ();
  9191. yySkip (); readtPosition ((* yyt)->String.pos) yyReadNl ();
  9192. return;
  9193. case kCurrent:
  9194. yySkip (); readtPosition ((* yyt)->Current.pos) yyReadNl ();
  9195. return;
  9196. case kResult:
  9197. yySkip (); readtPosition ((* yyt)->Result.pos) yyReadNl ();
  9198. return;
  9199. case kId:
  9200. yySkip (); readtIdent ((* yyt)->Id.ident) yyReadNl ();
  9201. yySkip (); readtPosition ((* yyt)->Id.pos) yyReadNl ();
  9202. return;
  9203.   default: return;
  9204.   }
  9205.  }
  9206. }
  9207.  
  9208. tTree ReadTree
  9209. # if defined __STDC__ | defined __cplusplus
  9210.  (FILE * yyyf)
  9211. # else
  9212.  (yyyf) FILE * yyyf;
  9213. # endif
  9214. {
  9215.  tTree yyt;
  9216.  yyf = yyyf;
  9217.  if (yyRecursionLevel ++ == 0) yyLabelCount = 0;
  9218.  if (! yyIsInitialized) {
  9219.   register int yyi;
  9220.   for (yyi = 0; yyi <= 192; yyi ++)
  9221.    yyKindToIdent [yyi] = MakeIdent ((tString) Tree_NodeName [yyi], strlen (Tree_NodeName [yyi]));
  9222.   yyIsInitialized = true;
  9223.  }
  9224.  yyReadTree (& yyt);
  9225.  yyRecursionLevel --;
  9226.  return yyt;
  9227. }
  9228.  
  9229. # define yyNil    0374
  9230. # define yyNoLabel    0375
  9231. # define yyLabelDef    0376
  9232. # define yyLabelUse    0377
  9233.  
  9234. static void yyPut
  9235. # if defined __STDC__ | defined __cplusplus
  9236.  (char * yyx, int yysize)
  9237. # else
  9238.  (yyx, yysize) char * yyx; int yysize;
  9239. # endif
  9240. { (void) fwrite (yyx, 1, yysize, yyf); }
  9241.  
  9242. static void yyPutIdent
  9243. # if defined __STDC__ | defined __cplusplus
  9244.  (tIdent yyi)
  9245. # else
  9246.  (yyi) tIdent yyi;
  9247. # endif
  9248. {
  9249.  char yys [256];
  9250.  GetString (yyi, (tString) yys);
  9251.  (void) fprintf (yyf, "%s\n", yys);
  9252. }
  9253.  
  9254. static void yyPutTree
  9255. # if defined __STDC__ | defined __cplusplus
  9256.  (tTree yyt)
  9257. # else
  9258.  (yyt) tTree yyt;
  9259. # endif
  9260. {
  9261.  static Tree_tLabel yyLabel;
  9262.  for (;;) {
  9263.   if (yyt == NoTree) {
  9264.    (void) putc (yyNil, yyf); return;
  9265.   } else if (yyt->yyHead.yyMark == 0) {
  9266.    (void) putc (yyLabelUse, yyf); yyLabel = yyMapToLabel (yyt); yyPut ((char *) & yyLabel, sizeof (yyLabel)); return;
  9267.   } else if (yyt->yyHead.yyMark > 1) {
  9268.    (void) putc (yyLabelDef, yyf); yyLabel = yyMapToLabel (yyt); yyPut ((char *) & yyLabel, sizeof (yyLabel));
  9269.    (void) putc ((char) yyt->Kind, yyf);
  9270.   } else {
  9271.    (void) putc ((char) yyt->Kind, yyf);
  9272.   }
  9273.   yyt->yyHead.yyMark = 0;
  9274.  
  9275.   switch (yyt->Kind) {
  9276. case kEiffel:
  9277. yyt = yyt->Eiffel.Classes; break;
  9278. case kClasses1:
  9279. puttTree (yyt->Classes1.Class_declaration)
  9280. yyt = yyt->Classes1.Classes; break;
  9281. case kClass_declaration:
  9282. puttTree (yyt->Class_declaration.Indexing)
  9283. puttTree (yyt->Class_declaration.Class_header)
  9284. puttTree (yyt->Class_declaration.Formal_generics)
  9285. puttTree (yyt->Class_declaration.Obsolete)
  9286. puttTree (yyt->Class_declaration.Inheritance)
  9287. puttTree (yyt->Class_declaration.Creators)
  9288. puttTree (yyt->Class_declaration.Features)
  9289. puttStringRef (yyt->Class_declaration.comment)
  9290. yyt = yyt->Class_declaration.Invariant; break;
  9291. case kIndex_list1:
  9292. puttTree (yyt->Index_list1.Index_clause)
  9293. yyt = yyt->Index_list1.Index_list; break;
  9294. case kIndex_clause:
  9295. puttTree (yyt->Index_clause.Index)
  9296. yyt = yyt->Index_clause.Index_terms; break;
  9297. case kClass:
  9298. yyt = yyt->Class.Name; break;
  9299. case kExpanded_class:
  9300. yyt = yyt->Expanded_class.Name; break;
  9301. case kDeferred_class:
  9302. yyt = yyt->Deferred_class.Name; break;
  9303. case kFeatures1:
  9304. puttTree (yyt->Features1.Feature_clause)
  9305. yyt = yyt->Features1.Features; break;
  9306. case kFeature_clause:
  9307. puttTree (yyt->Feature_clause.Clients)
  9308. puttStringRef (yyt->Feature_clause.comment)
  9309. yyt = yyt->Feature_clause.Feature_decls; break;
  9310. case kClients1:
  9311. yyt = yyt->Clients1.List; break;
  9312. case kFeature_decls1:
  9313. puttTree (yyt->Feature_decls1.Feature_decl)
  9314. yyt = yyt->Feature_decls1.Feature_decls; break;
  9315. case kFeature_decl:
  9316. puttTree (yyt->Feature_decl.New_feature_list)
  9317. yyt = yyt->Feature_decl.Declaration_body; break;
  9318. case kDeclaration_body:
  9319. puttTree (yyt->Declaration_body.Formal_args)
  9320. puttTree (yyt->Declaration_body.Type_mark)
  9321. yyt = yyt->Declaration_body.Const_or_routine; break;
  9322. case kM_const:
  9323. yyt = yyt->M_const.Manifest_constant; break;
  9324. case kUnique:
  9325. puttPosition (yyt->Unique.pos)
  9326. return;
  9327. case kRoutine:
  9328. puttTree (yyt->Routine.Obsolete)
  9329. puttStringRef (yyt->Routine.comment)
  9330. puttTree (yyt->Routine.Precondition)
  9331. puttTree (yyt->Routine.Local_decls)
  9332. puttTree (yyt->Routine.Routine_body)
  9333. puttTree (yyt->Routine.Postcondition)
  9334. puttStringRef (yyt->Routine.end_comment)
  9335. yyt = yyt->Routine.Rescue; break;
  9336. case kParent_list1:
  9337. puttTree (yyt->Parent_list1.Parent)
  9338. yyt = yyt->Parent_list1.Parent_list; break;
  9339. case kParent:
  9340. puttTree (yyt->Parent.Class_type)
  9341. yyt = yyt->Parent.Feature_adaptation; break;
  9342. case kFeature_adaptation1:
  9343. puttTree (yyt->Feature_adaptation1.Rename)
  9344. puttTree (yyt->Feature_adaptation1.New_export)
  9345. puttTree (yyt->Feature_adaptation1.Undefine)
  9346. puttTree (yyt->Feature_adaptation1.Redefine)
  9347. yyt = yyt->Feature_adaptation1.Select; break;
  9348. case kRename_list1:
  9349. puttTree (yyt->Rename_list1.Rename_pair)
  9350. yyt = yyt->Rename_list1.Rename_list; break;
  9351. case kRename_pair:
  9352. puttTree (yyt->Rename_pair.Name1)
  9353. yyt = yyt->Rename_pair.Name2; break;
  9354. case kCreators1:
  9355. puttTree (yyt->Creators1.Creation_clause)
  9356. yyt = yyt->Creators1.Creators; break;
  9357. case kCreation_clause:
  9358. puttTree (yyt->Creation_clause.Clients)
  9359. puttStringRef (yyt->Creation_clause.comment)
  9360. yyt = yyt->Creation_clause.Feature_list; break;
  9361. case kNew_feature_list1:
  9362. puttTree (yyt->New_feature_list1.Feature_name)
  9363. yyt = yyt->New_feature_list1.New_feature_list; break;
  9364. case kFrozen:
  9365. yyt = yyt->Frozen.Feature_name; break;
  9366. case kIdent_name:
  9367. yyt = yyt->Ident_name.Id; break;
  9368. case kPrefix:
  9369. yyt = yyt->Prefix.Op_name; break;
  9370. case kInfix:
  9371. yyt = yyt->Infix.Op_name; break;
  9372. case kOp_name:
  9373. puttPosition (yyt->Op_name.pos)
  9374. return;
  9375. case kFree_op:
  9376. puttPosition (yyt->Free_op.pos)
  9377. puttIdent (yyt->Free_op.ident)
  9378. return;
  9379. case kOper:
  9380. puttPosition (yyt->Oper.pos)
  9381. putint (yyt->Oper.op)
  9382. return;
  9383. case kNew_export_list1:
  9384. puttTree (yyt->New_export_list1.New_export_item)
  9385. yyt = yyt->New_export_list1.New_export_list; break;
  9386. case kNew_export_item:
  9387. puttTree (yyt->New_export_item.Clients)
  9388. yyt = yyt->New_export_item.Feature_set; break;
  9389. case kFeature_list1:
  9390. puttTree (yyt->Feature_list1.Feature_name)
  9391. yyt = yyt->Feature_list1.Feature_list; break;
  9392. case kFormal_args1:
  9393. puttTree (yyt->Formal_args1.Entity_decl_group)
  9394. yyt = yyt->Formal_args1.Formal_args; break;
  9395. case kDo_body:
  9396. yyt = yyt->Do_body.Compound; break;
  9397. case kOnce_body:
  9398. yyt = yyt->Once_body.Compound; break;
  9399. case kExternal:
  9400. puttTree (yyt->External.Lang1)
  9401. yyt = yyt->External.Lang2; break;
  9402. case kDeferred:
  9403. puttPosition (yyt->Deferred.pos)
  9404. return;
  9405. case kEntity_decl_group:
  9406. puttTree (yyt->Entity_decl_group.Id_list)
  9407. yyt = yyt->Entity_decl_group.Type_mark; break;
  9408. case kFormal_generics1:
  9409. puttTree (yyt->Formal_generics1.Formal_generic)
  9410. yyt = yyt->Formal_generics1.Formal_generics; break;
  9411. case kFormal_generic:
  9412. puttTree (yyt->Formal_generic.Id)
  9413. yyt = yyt->Formal_generic.Constraint; break;
  9414. case kConstraint1:
  9415. yyt = yyt->Constraint1.Class_type; break;
  9416. case kCompound1:
  9417. puttTree (yyt->Compound1.Instruction)
  9418. yyt = yyt->Compound1.Compound; break;
  9419. case kThen_part_list1:
  9420. puttTree (yyt->Then_part_list1.Then_part)
  9421. yyt = yyt->Then_part_list1.Then_part_list; break;
  9422. case kThen_part:
  9423. puttTree (yyt->Then_part.Guard)
  9424. yyt = yyt->Then_part.Compound; break;
  9425. case kWhen_part_list1:
  9426. puttTree (yyt->When_part_list1.When_part)
  9427. yyt = yyt->When_part_list1.When_part_list; break;
  9428. case kWhen_part:
  9429. puttTree (yyt->When_part.Choices)
  9430. yyt = yyt->When_part.Compound; break;
  9431. case kChoices1:
  9432. puttTree (yyt->Choices1.Choice)
  9433. yyt = yyt->Choices1.Choices; break;
  9434. case kInterval:
  9435. puttTree (yyt->Interval.From)
  9436. yyt = yyt->Interval.To; break;
  9437. case kVal:
  9438. yyt = yyt->Val.Manifest_constant; break;
  9439. case kCreation:
  9440. puttTree (yyt->Creation.Type)
  9441. puttTree (yyt->Creation.Entity)
  9442. yyt = yyt->Creation.Unqual_call; break;
  9443. case kCall_instruct:
  9444. yyt = yyt->Call_instruct.Call; break;
  9445. case kAssign:
  9446. puttTree (yyt->Assign.Addr)
  9447. yyt = yyt->Assign.Expression; break;
  9448. case kRev_assign:
  9449. puttTree (yyt->Rev_assign.Addr)
  9450. yyt = yyt->Rev_assign.Expression; break;
  9451. case kConditional:
  9452. puttTree (yyt->Conditional.Then_part)
  9453. yyt = yyt->Conditional.Else_part; break;
  9454. case kMulti_branch:
  9455. puttTree (yyt->Multi_branch.Guard)
  9456. puttTree (yyt->Multi_branch.When_part_list)
  9457. yyt = yyt->Multi_branch.Else_part; break;
  9458. case kLoop:
  9459. puttTree (yyt->Loop.Initialization)
  9460. puttTree (yyt->Loop.Invariant)
  9461. puttTree (yyt->Loop.Variant)
  9462. yyt = yyt->Loop.Loop_body; break;
  9463. case kCheck:
  9464. yyt = yyt->Check.Assertion; break;
  9465. case kDebug:
  9466. puttTree (yyt->Debug.Debug_keys)
  9467. yyt = yyt->Debug.Compound; break;
  9468. case kRetry:
  9469. puttPosition (yyt->Retry.pos)
  9470. return;
  9471. case kLoop_body1:
  9472. puttTree (yyt->Loop_body1.Exit)
  9473. yyt = yyt->Loop_body1.Compound; break;
  9474. case kClass_type:
  9475. puttTree (yyt->Class_type.Id)
  9476. yyt = yyt->Class_type.Actual_generics; break;
  9477. case kClass_type_expanded:
  9478. puttTree (yyt->Class_type_expanded.Id)
  9479. yyt = yyt->Class_type_expanded.Actual_generics; break;
  9480. case kBit_type:
  9481. yyt = yyt->Bit_type.Manifest_constant; break;
  9482. case kSimple_type:
  9483. yyt = yyt->Simple_type.Manifest_constant; break;
  9484. case kAnchored:
  9485. yyt = yyt->Anchored.Entity; break;
  9486. case kActual_generics1:
  9487. yyt = yyt->Actual_generics1.Type_list; break;
  9488. case kCondition1:
  9489. putint (yyt->Condition1.extension)
  9490. yyt = yyt->Condition1.Assertion; break;
  9491. case kAssertion1:
  9492. puttTree (yyt->Assertion1.Assertion_clause)
  9493. yyt = yyt->Assertion1.Assertion; break;
  9494. case kAssertion_clause1:
  9495. puttTree (yyt->Assertion_clause1.Tag)
  9496. yyt = yyt->Assertion_clause1.Expression; break;
  9497. case kType_list1:
  9498. puttTree (yyt->Type_list1.Type)
  9499. yyt = yyt->Type_list1.Type_list; break;
  9500. case kCall_chain1:
  9501. puttTree (yyt->Call_chain1.Unqual_call)
  9502. yyt = yyt->Call_chain1.Call_chain; break;
  9503. case kUnqual_call1:
  9504. puttTree (yyt->Unqual_call1.Entity)
  9505. yyt = yyt->Unqual_call1.Actuals; break;
  9506. case kActuals1:
  9507. yyt = yyt->Actuals1.Actual_list; break;
  9508. case kActual_list1:
  9509. puttTree (yyt->Actual_list1.Actual)
  9510. yyt = yyt->Actual_list1.Actual_list; break;
  9511. case kAddr:
  9512. yyt = yyt->Addr.Entity; break;
  9513. case kComment:
  9514. puttStringRef (yyt->Comment.comment)
  9515. return;
  9516. case kSimple_expr:
  9517. yyt = yyt->Simple_expr.Manifest_constant; break;
  9518. case kCall:
  9519. puttTree (yyt->Call.Qual)
  9520. yyt = yyt->Call.Call_chain; break;
  9521. case kBin_expr:
  9522. puttTree (yyt->Bin_expr.Lop)
  9523. puttTree (yyt->Bin_expr.Op)
  9524. yyt = yyt->Bin_expr.Rop; break;
  9525. case kUn_expr:
  9526. puttTree (yyt->Un_expr.Op)
  9527. yyt = yyt->Un_expr.Expression; break;
  9528. case kParenth:
  9529. yyt = yyt->Parenth.Expression; break;
  9530. case kManifest_array1:
  9531. puttTree (yyt->Manifest_array1.Expression)
  9532. yyt = yyt->Manifest_array1.Manifest_array; break;
  9533. case kOld:
  9534. yyt = yyt->Old.Expression; break;
  9535. case kStrip:
  9536. yyt = yyt->Strip.List; break;
  9537. case klist:
  9538. puttTree (yyt->list.Manifest_constant)
  9539. yyt = yyt->list.List; break;
  9540. case kCh:
  9541. putint (yyt->Ch.ch)
  9542. puttPosition (yyt->Ch.pos)
  9543. return;
  9544. case kTrue:
  9545. puttPosition (yyt->True.pos)
  9546. return;
  9547. case kFalse:
  9548. puttPosition (yyt->False.pos)
  9549. return;
  9550. case kInt:
  9551. putlong (yyt->Int.value)
  9552. puttPosition (yyt->Int.pos)
  9553. yyt = yyt->Int.Sign; break;
  9554. case kReal:
  9555. putdouble (yyt->Real.value)
  9556. puttPosition (yyt->Real.pos)
  9557. yyt = yyt->Real.Sign; break;
  9558. case k_CHARACTER:
  9559. puttPosition (yyt->_CHARACTER.pos)
  9560. return;
  9561. case k_INTEGER:
  9562. puttPosition (yyt->_INTEGER.pos)
  9563. return;
  9564. case k_REAL:
  9565. puttPosition (yyt->_REAL.pos)
  9566. return;
  9567. case k_DOUBLE:
  9568. puttPosition (yyt->_DOUBLE.pos)
  9569. return;
  9570. case k_BOOLEAN:
  9571. puttPosition (yyt->_BOOLEAN.pos)
  9572. return;
  9573. case k_STRING:
  9574. puttPosition (yyt->_STRING.pos)
  9575. return;
  9576. case k_BIT:
  9577. puttPosition (yyt->_BIT.pos)
  9578. return;
  9579. case k_NONE:
  9580. puttPosition (yyt->_NONE.pos)
  9581. return;
  9582. case kBitseq:
  9583. puttStringRef (yyt->Bitseq.literal)
  9584. puttPosition (yyt->Bitseq.pos)
  9585. return;
  9586. case kString:
  9587. puttStringRef (yyt->String.string)
  9588. puttPosition (yyt->String.pos)
  9589. return;
  9590. case kCurrent:
  9591. puttPosition (yyt->Current.pos)
  9592. return;
  9593. case kResult:
  9594. puttPosition (yyt->Result.pos)
  9595. return;
  9596. case kId:
  9597. puttIdent (yyt->Id.ident)
  9598. puttPosition (yyt->Id.pos)
  9599. return;
  9600.   default: return;
  9601.   }
  9602.  }
  9603. }
  9604.  
  9605. void PutTree
  9606. # if defined __STDC__ | defined __cplusplus
  9607.  (FILE * yyyf, tTree yyt)
  9608. # else
  9609.  (yyyf, yyt) FILE * yyyf; tTree yyt;
  9610. # endif
  9611. {
  9612.  yyf = yyyf;
  9613.  if (yyRecursionLevel ++ == 0) yyLabelCount = 0;
  9614.  yyMark (yyt);
  9615.  yyPutTree (yyt);
  9616.  yyRecursionLevel --;
  9617. }
  9618.  
  9619. static void yyGet
  9620. # if defined __STDC__ | defined __cplusplus
  9621.  (char * yyx, int yysize)
  9622. # else
  9623.  (yyx, yysize) char * yyx; int yysize;
  9624. # endif
  9625. { (void) fread (yyx, 1, yysize, yyf); }
  9626.  
  9627. static void yyGetIdent
  9628. # if defined __STDC__ | defined __cplusplus
  9629.  (tIdent * yyi)
  9630. # else
  9631.  (yyi) tIdent * yyi;
  9632. # endif
  9633. {
  9634.  char yys [256];
  9635.  (void) fscanf (yyf, "%s%*c", yys);
  9636.  * yyi = MakeIdent ((tString) yys, strlen (yys));
  9637. }
  9638.  
  9639. static void yyGetTree
  9640. # if defined __STDC__ | defined __cplusplus
  9641.  (yyPtrtTree yyt)
  9642. # else
  9643.  (yyt) yyPtrtTree yyt;
  9644. # endif
  9645. {
  9646.  static Tree_tLabel yyLabel;
  9647.  static Tree_tKind yyKind;
  9648.  for (;;) {
  9649.   switch (yyKind = getc (yyf)) {
  9650.   case yyNil        : * yyt = NoTree; return;
  9651.   case yyLabelUse    : yyGet ((char *) & yyLabel, sizeof (yyLabel));
  9652.    * yyt = yyMapToTree (yyLabel); return;
  9653.   case yyLabelDef    : yyGet ((char *) & yyLabel, sizeof (yyLabel));
  9654.    yyKind = getc (yyf);   * yyt = MakeTree (yyKind);
  9655.    if (yyLabel != yyMapToLabel (* yyt)) { (void) fputs ("Tree: error in GetTree\n", stderr); Tree_Exit (); } break;
  9656.   default    : * yyt = MakeTree (yyKind);
  9657.   }
  9658.  
  9659.   switch (yyKind) {
  9660. case kEiffel:
  9661. yyt = & ((* yyt)->Eiffel.Classes); break;
  9662. case kClasses1:
  9663. gettTree (& ((* yyt)->Classes1.Class_declaration))
  9664. yyt = & ((* yyt)->Classes1.Classes); break;
  9665. case kClass_declaration:
  9666. gettTree (& ((* yyt)->Class_declaration.Indexing))
  9667. gettTree (& ((* yyt)->Class_declaration.Class_header))
  9668. gettTree (& ((* yyt)->Class_declaration.Formal_generics))
  9669. gettTree (& ((* yyt)->Class_declaration.Obsolete))
  9670. gettTree (& ((* yyt)->Class_declaration.Inheritance))
  9671. gettTree (& ((* yyt)->Class_declaration.Creators))
  9672. gettTree (& ((* yyt)->Class_declaration.Features))
  9673. gettStringRef ((* yyt)->Class_declaration.comment)
  9674. yyt = & ((* yyt)->Class_declaration.Invariant); break;
  9675. case kIndex_list1:
  9676. gettTree (& ((* yyt)->Index_list1.Index_clause))
  9677. yyt = & ((* yyt)->Index_list1.Index_list); break;
  9678. case kIndex_clause:
  9679. gettTree (& ((* yyt)->Index_clause.Index))
  9680. yyt = & ((* yyt)->Index_clause.Index_terms); break;
  9681. case kClass:
  9682. yyt = & ((* yyt)->Class.Name); break;
  9683. case kExpanded_class:
  9684. yyt = & ((* yyt)->Expanded_class.Name); break;
  9685. case kDeferred_class:
  9686. yyt = & ((* yyt)->Deferred_class.Name); break;
  9687. case kFeatures1:
  9688. gettTree (& ((* yyt)->Features1.Feature_clause))
  9689. yyt = & ((* yyt)->Features1.Features); break;
  9690. case kFeature_clause:
  9691. gettTree (& ((* yyt)->Feature_clause.Clients))
  9692. gettStringRef ((* yyt)->Feature_clause.comment)
  9693. yyt = & ((* yyt)->Feature_clause.Feature_decls); break;
  9694. case kClients1:
  9695. yyt = & ((* yyt)->Clients1.List); break;
  9696. case kFeature_decls1:
  9697. gettTree (& ((* yyt)->Feature_decls1.Feature_decl))
  9698. yyt = & ((* yyt)->Feature_decls1.Feature_decls); break;
  9699. case kFeature_decl:
  9700. gettTree (& ((* yyt)->Feature_decl.New_feature_list))
  9701. yyt = & ((* yyt)->Feature_decl.Declaration_body); break;
  9702. case kDeclaration_body:
  9703. gettTree (& ((* yyt)->Declaration_body.Formal_args))
  9704. gettTree (& ((* yyt)->Declaration_body.Type_mark))
  9705. yyt = & ((* yyt)->Declaration_body.Const_or_routine); break;
  9706. case kM_const:
  9707. yyt = & ((* yyt)->M_const.Manifest_constant); break;
  9708. case kUnique:
  9709. gettPosition ((* yyt)->Unique.pos)
  9710. return;
  9711. case kRoutine:
  9712. gettTree (& ((* yyt)->Routine.Obsolete))
  9713. gettStringRef ((* yyt)->Routine.comment)
  9714. gettTree (& ((* yyt)->Routine.Precondition))
  9715. gettTree (& ((* yyt)->Routine.Local_decls))
  9716. gettTree (& ((* yyt)->Routine.Routine_body))
  9717. gettTree (& ((* yyt)->Routine.Postcondition))
  9718. gettStringRef ((* yyt)->Routine.end_comment)
  9719. yyt = & ((* yyt)->Routine.Rescue); break;
  9720. case kParent_list1:
  9721. gettTree (& ((* yyt)->Parent_list1.Parent))
  9722. yyt = & ((* yyt)->Parent_list1.Parent_list); break;
  9723. case kParent:
  9724. gettTree (& ((* yyt)->Parent.Class_type))
  9725. yyt = & ((* yyt)->Parent.Feature_adaptation); break;
  9726. case kFeature_adaptation1:
  9727. gettTree (& ((* yyt)->Feature_adaptation1.Rename))
  9728. gettTree (& ((* yyt)->Feature_adaptation1.New_export))
  9729. gettTree (& ((* yyt)->Feature_adaptation1.Undefine))
  9730. gettTree (& ((* yyt)->Feature_adaptation1.Redefine))
  9731. yyt = & ((* yyt)->Feature_adaptation1.Select); break;
  9732. case kRename_list1:
  9733. gettTree (& ((* yyt)->Rename_list1.Rename_pair))
  9734. yyt = & ((* yyt)->Rename_list1.Rename_list); break;
  9735. case kRename_pair:
  9736. gettTree (& ((* yyt)->Rename_pair.Name1))
  9737. yyt = & ((* yyt)->Rename_pair.Name2); break;
  9738. case kCreators1:
  9739. gettTree (& ((* yyt)->Creators1.Creation_clause))
  9740. yyt = & ((* yyt)->Creators1.Creators); break;
  9741. case kCreation_clause:
  9742. gettTree (& ((* yyt)->Creation_clause.Clients))
  9743. gettStringRef ((* yyt)->Creation_clause.comment)
  9744. yyt = & ((* yyt)->Creation_clause.Feature_list); break;
  9745. case kNew_feature_list1:
  9746. gettTree (& ((* yyt)->New_feature_list1.Feature_name))
  9747. yyt = & ((* yyt)->New_feature_list1.New_feature_list); break;
  9748. case kFrozen:
  9749. yyt = & ((* yyt)->Frozen.Feature_name); break;
  9750. case kIdent_name:
  9751. yyt = & ((* yyt)->Ident_name.Id); break;
  9752. case kPrefix:
  9753. yyt = & ((* yyt)->Prefix.Op_name); break;
  9754. case kInfix:
  9755. yyt = & ((* yyt)->Infix.Op_name); break;
  9756. case kOp_name:
  9757. gettPosition ((* yyt)->Op_name.pos)
  9758. return;
  9759. case kFree_op:
  9760. gettPosition ((* yyt)->Free_op.pos)
  9761. gettIdent ((* yyt)->Free_op.ident)
  9762. return;
  9763. case kOper:
  9764. gettPosition ((* yyt)->Oper.pos)
  9765. getint ((* yyt)->Oper.op)
  9766. return;
  9767. case kNew_export_list1:
  9768. gettTree (& ((* yyt)->New_export_list1.New_export_item))
  9769. yyt = & ((* yyt)->New_export_list1.New_export_list); break;
  9770. case kNew_export_item:
  9771. gettTree (& ((* yyt)->New_export_item.Clients))
  9772. yyt = & ((* yyt)->New_export_item.Feature_set); break;
  9773. case kFeature_list1:
  9774. gettTree (& ((* yyt)->Feature_list1.Feature_name))
  9775. yyt = & ((* yyt)->Feature_list1.Feature_list); break;
  9776. case kFormal_args1:
  9777. gettTree (& ((* yyt)->Formal_args1.Entity_decl_group))
  9778. yyt = & ((* yyt)->Formal_args1.Formal_args); break;
  9779. case kDo_body:
  9780. yyt = & ((* yyt)->Do_body.Compound); break;
  9781. case kOnce_body:
  9782. yyt = & ((* yyt)->Once_body.Compound); break;
  9783. case kExternal:
  9784. gettTree (& ((* yyt)->External.Lang1))
  9785. yyt = & ((* yyt)->External.Lang2); break;
  9786. case kDeferred:
  9787. gettPosition ((* yyt)->Deferred.pos)
  9788. return;
  9789. case kEntity_decl_group:
  9790. gettTree (& ((* yyt)->Entity_decl_group.Id_list))
  9791. yyt = & ((* yyt)->Entity_decl_group.Type_mark); break;
  9792. case kFormal_generics1:
  9793. gettTree (& ((* yyt)->Formal_generics1.Formal_generic))
  9794. yyt = & ((* yyt)->Formal_generics1.Formal_generics); break;
  9795. case kFormal_generic:
  9796. gettTree (& ((* yyt)->Formal_generic.Id))
  9797. yyt = & ((* yyt)->Formal_generic.Constraint); break;
  9798. case kConstraint1:
  9799. yyt = & ((* yyt)->Constraint1.Class_type); break;
  9800. case kCompound1:
  9801. gettTree (& ((* yyt)->Compound1.Instruction))
  9802. yyt = & ((* yyt)->Compound1.Compound); break;
  9803. case kThen_part_list1:
  9804. gettTree (& ((* yyt)->Then_part_list1.Then_part))
  9805. yyt = & ((* yyt)->Then_part_list1.Then_part_list); break;
  9806. case kThen_part:
  9807. gettTree (& ((* yyt)->Then_part.Guard))
  9808. yyt = & ((* yyt)->Then_part.Compound); break;
  9809. case kWhen_part_list1:
  9810. gettTree (& ((* yyt)->When_part_list1.When_part))
  9811. yyt = & ((* yyt)->When_part_list1.When_part_list); break;
  9812. case kWhen_part:
  9813. gettTree (& ((* yyt)->When_part.Choices))
  9814. yyt = & ((* yyt)->When_part.Compound); break;
  9815. case kChoices1:
  9816. gettTree (& ((* yyt)->Choices1.Choice))
  9817. yyt = & ((* yyt)->Choices1.Choices); break;
  9818. case kInterval:
  9819. gettTree (& ((* yyt)->Interval.From))
  9820. yyt = & ((* yyt)->Interval.To); break;
  9821. case kVal:
  9822. yyt = & ((* yyt)->Val.Manifest_constant); break;
  9823. case kCreation:
  9824. gettTree (& ((* yyt)->Creation.Type))
  9825. gettTree (& ((* yyt)->Creation.Entity))
  9826. yyt = & ((* yyt)->Creation.Unqual_call); break;
  9827. case kCall_instruct:
  9828. yyt = & ((* yyt)->Call_instruct.Call); break;
  9829. case kAssign:
  9830. gettTree (& ((* yyt)->Assign.Addr))
  9831. yyt = & ((* yyt)->Assign.Expression); break;
  9832. case kRev_assign:
  9833. gettTree (& ((* yyt)->Rev_assign.Addr))
  9834. yyt = & ((* yyt)->Rev_assign.Expression); break;
  9835. case kConditional:
  9836. gettTree (& ((* yyt)->Conditional.Then_part))
  9837. yyt = & ((* yyt)->Conditional.Else_part); break;
  9838. case kMulti_branch:
  9839. gettTree (& ((* yyt)->Multi_branch.Guard))
  9840. gettTree (& ((* yyt)->Multi_branch.When_part_list))
  9841. yyt = & ((* yyt)->Multi_branch.Else_part); break;
  9842. case kLoop:
  9843. gettTree (& ((* yyt)->Loop.Initialization))
  9844. gettTree (& ((* yyt)->Loop.Invariant))
  9845. gettTree (& ((* yyt)->Loop.Variant))
  9846. yyt = & ((* yyt)->Loop.Loop_body); break;
  9847. case kCheck:
  9848. yyt = & ((* yyt)->Check.Assertion); break;
  9849. case kDebug:
  9850. gettTree (& ((* yyt)->Debug.Debug_keys))
  9851. yyt = & ((* yyt)->Debug.Compound); break;
  9852. case kRetry:
  9853. gettPosition ((* yyt)->Retry.pos)
  9854. return;
  9855. case kLoop_body1:
  9856. gettTree (& ((* yyt)->Loop_body1.Exit))
  9857. yyt = & ((* yyt)->Loop_body1.Compound); break;
  9858. case kClass_type:
  9859. gettTree (& ((* yyt)->Class_type.Id))
  9860. yyt = & ((* yyt)->Class_type.Actual_generics); break;
  9861. case kClass_type_expanded:
  9862. gettTree (& ((* yyt)->Class_type_expanded.Id))
  9863. yyt = & ((* yyt)->Class_type_expanded.Actual_generics); break;
  9864. case kBit_type:
  9865. yyt = & ((* yyt)->Bit_type.Manifest_constant); break;
  9866. case kSimple_type:
  9867. yyt = & ((* yyt)->Simple_type.Manifest_constant); break;
  9868. case kAnchored:
  9869. yyt = & ((* yyt)->Anchored.Entity); break;
  9870. case kActual_generics1:
  9871. yyt = & ((* yyt)->Actual_generics1.Type_list); break;
  9872. case kCondition1:
  9873. getint ((* yyt)->Condition1.extension)
  9874. yyt = & ((* yyt)->Condition1.Assertion); break;
  9875. case kAssertion1:
  9876. gettTree (& ((* yyt)->Assertion1.Assertion_clause))
  9877. yyt = & ((* yyt)->Assertion1.Assertion); break;
  9878. case kAssertion_clause1:
  9879. gettTree (& ((* yyt)->Assertion_clause1.Tag))
  9880. yyt = & ((* yyt)->Assertion_clause1.Expression); break;
  9881. case kType_list1:
  9882. gettTree (& ((* yyt)->Type_list1.Type))
  9883. yyt = & ((* yyt)->Type_list1.Type_list); break;
  9884. case kCall_chain1:
  9885. gettTree (& ((* yyt)->Call_chain1.Unqual_call))
  9886. yyt = & ((* yyt)->Call_chain1.Call_chain); break;
  9887. case kUnqual_call1:
  9888. gettTree (& ((* yyt)->Unqual_call1.Entity))
  9889. yyt = & ((* yyt)->Unqual_call1.Actuals); break;
  9890. case kActuals1:
  9891. yyt = & ((* yyt)->Actuals1.Actual_list); break;
  9892. case kActual_list1:
  9893. gettTree (& ((* yyt)->Actual_list1.Actual))
  9894. yyt = & ((* yyt)->Actual_list1.Actual_list); break;
  9895. case kAddr:
  9896. yyt = & ((* yyt)->Addr.Entity); break;
  9897. case kComment:
  9898. gettStringRef ((* yyt)->Comment.comment)
  9899. return;
  9900. case kSimple_expr:
  9901. yyt = & ((* yyt)->Simple_expr.Manifest_constant); break;
  9902. case kCall:
  9903. gettTree (& ((* yyt)->Call.Qual))
  9904. yyt = & ((* yyt)->Call.Call_chain); break;
  9905. case kBin_expr:
  9906. gettTree (& ((* yyt)->Bin_expr.Lop))
  9907. gettTree (& ((* yyt)->Bin_expr.Op))
  9908. yyt = & ((* yyt)->Bin_expr.Rop); break;
  9909. case kUn_expr:
  9910. gettTree (& ((* yyt)->Un_expr.Op))
  9911. yyt = & ((* yyt)->Un_expr.Expression); break;
  9912. case kParenth:
  9913. yyt = & ((* yyt)->Parenth.Expression); break;
  9914. case kManifest_array1:
  9915. gettTree (& ((* yyt)->Manifest_array1.Expression))
  9916. yyt = & ((* yyt)->Manifest_array1.Manifest_array); break;
  9917. case kOld:
  9918. yyt = & ((* yyt)->Old.Expression); break;
  9919. case kStrip:
  9920. yyt = & ((* yyt)->Strip.List); break;
  9921. case klist:
  9922. gettTree (& ((* yyt)->list.Manifest_constant))
  9923. yyt = & ((* yyt)->list.List); break;
  9924. case kCh:
  9925. getint ((* yyt)->Ch.ch)
  9926. gettPosition ((* yyt)->Ch.pos)
  9927. return;
  9928. case kTrue:
  9929. gettPosition ((* yyt)->True.pos)
  9930. return;
  9931. case kFalse:
  9932. gettPosition ((* yyt)->False.pos)
  9933. return;
  9934. case kInt:
  9935. getlong ((* yyt)->Int.value)
  9936. gettPosition ((* yyt)->Int.pos)
  9937. yyt = & ((* yyt)->Int.Sign); break;
  9938. case kReal:
  9939. getdouble ((* yyt)->Real.value)
  9940. gettPosition ((* yyt)->Real.pos)
  9941. yyt = & ((* yyt)->Real.Sign); break;
  9942. case k_CHARACTER:
  9943. gettPosition ((* yyt)->_CHARACTER.pos)
  9944. return;
  9945. case k_INTEGER:
  9946. gettPosition ((* yyt)->_INTEGER.pos)
  9947. return;
  9948. case k_REAL:
  9949. gettPosition ((* yyt)->_REAL.pos)
  9950. return;
  9951. case k_DOUBLE:
  9952. gettPosition ((* yyt)->_DOUBLE.pos)
  9953. return;
  9954. case k_BOOLEAN:
  9955. gettPosition ((* yyt)->_BOOLEAN.pos)
  9956. return;
  9957. case k_STRING:
  9958. gettPosition ((* yyt)->_STRING.pos)
  9959. return;
  9960. case k_BIT:
  9961. gettPosition ((* yyt)->_BIT.pos)
  9962. return;
  9963. case k_NONE:
  9964. gettPosition ((* yyt)->_NONE.pos)
  9965. return;
  9966. case kBitseq:
  9967. gettStringRef ((* yyt)->Bitseq.literal)
  9968. gettPosition ((* yyt)->Bitseq.pos)
  9969. return;
  9970. case kString:
  9971. gettStringRef ((* yyt)->String.string)
  9972. gettPosition ((* yyt)->String.pos)
  9973. return;
  9974. case kCurrent:
  9975. gettPosition ((* yyt)->Current.pos)
  9976. return;
  9977. case kResult:
  9978. gettPosition ((* yyt)->Result.pos)
  9979. return;
  9980. case kId:
  9981. gettIdent ((* yyt)->Id.ident)
  9982. gettPosition ((* yyt)->Id.pos)
  9983. return;
  9984.   default: return;
  9985.   }
  9986.  }
  9987. }
  9988.  
  9989. tTree GetTree
  9990. # if defined __STDC__ | defined __cplusplus
  9991.  (FILE * yyyf)
  9992. # else
  9993.  (yyyf) FILE * yyyf;
  9994. # endif
  9995. {
  9996.  tTree yyt;
  9997.  yyf = yyyf;
  9998.  if (yyRecursionLevel ++ == 0) yyLabelCount = 0;
  9999.  yyGetTree (& yyt);
  10000.  yyRecursionLevel --;
  10001.  return yyt;
  10002. }
  10003.  
  10004. static tTree yyChild;
  10005.  
  10006. static void yyReleaseTree
  10007. # if defined __STDC__ | defined __cplusplus
  10008.  (tTree yyt)
  10009. # else
  10010.  (yyt) tTree yyt;
  10011. # endif
  10012. {
  10013.  if (yyt == NoTree) return;
  10014.  switch (yyt->Kind) {
  10015. case kEiffel:
  10016. closetTree (yyt->Eiffel.Classes)
  10017. break;
  10018. case kClasses1:
  10019. closetTree (yyt->Classes1.Class_declaration)
  10020. closetTree (yyt->Classes1.Classes)
  10021. break;
  10022. case kClass_declaration:
  10023. closetTree (yyt->Class_declaration.Indexing)
  10024. closetTree (yyt->Class_declaration.Class_header)
  10025. closetTree (yyt->Class_declaration.Formal_generics)
  10026. closetTree (yyt->Class_declaration.Obsolete)
  10027. closetTree (yyt->Class_declaration.Inheritance)
  10028. closetTree (yyt->Class_declaration.Creators)
  10029. closetTree (yyt->Class_declaration.Features)
  10030. closetTree (yyt->Class_declaration.Invariant)
  10031. break;
  10032. case kIndex_list1:
  10033. closetTree (yyt->Index_list1.Index_clause)
  10034. closetTree (yyt->Index_list1.Index_list)
  10035. break;
  10036. case kIndex_clause:
  10037. closetTree (yyt->Index_clause.Index)
  10038. closetTree (yyt->Index_clause.Index_terms)
  10039. break;
  10040. case kClass:
  10041. closetTree (yyt->Class.Name)
  10042. break;
  10043. case kExpanded_class:
  10044. closetTree (yyt->Expanded_class.Name)
  10045. break;
  10046. case kDeferred_class:
  10047. closetTree (yyt->Deferred_class.Name)
  10048. break;
  10049. case kFeatures1:
  10050. closetTree (yyt->Features1.Feature_clause)
  10051. closetTree (yyt->Features1.Features)
  10052. break;
  10053. case kFeature_clause:
  10054. closetTree (yyt->Feature_clause.Clients)
  10055. closetTree (yyt->Feature_clause.Feature_decls)
  10056. break;
  10057. case kClients1:
  10058. closetTree (yyt->Clients1.List)
  10059. break;
  10060. case kFeature_decls1:
  10061. closetTree (yyt->Feature_decls1.Feature_decl)
  10062. closetTree (yyt->Feature_decls1.Feature_decls)
  10063. break;
  10064. case kFeature_decl:
  10065. closetTree (yyt->Feature_decl.New_feature_list)
  10066. closetTree (yyt->Feature_decl.Declaration_body)
  10067. break;
  10068. case kDeclaration_body:
  10069. closetTree (yyt->Declaration_body.Formal_args)
  10070. closetTree (yyt->Declaration_body.Type_mark)
  10071. closetTree (yyt->Declaration_body.Const_or_routine)
  10072. break;
  10073. case kM_const:
  10074. closetTree (yyt->M_const.Manifest_constant)
  10075. break;
  10076. case kRoutine:
  10077. closetTree (yyt->Routine.Obsolete)
  10078. closetTree (yyt->Routine.Precondition)
  10079. closetTree (yyt->Routine.Local_decls)
  10080. closetTree (yyt->Routine.Routine_body)
  10081. closetTree (yyt->Routine.Postcondition)
  10082. closetTree (yyt->Routine.Rescue)
  10083. break;
  10084. case kParent_list1:
  10085. closetTree (yyt->Parent_list1.Parent)
  10086. closetTree (yyt->Parent_list1.Parent_list)
  10087. break;
  10088. case kParent:
  10089. closetTree (yyt->Parent.Class_type)
  10090. closetTree (yyt->Parent.Feature_adaptation)
  10091. break;
  10092. case kFeature_adaptation1:
  10093. closetTree (yyt->Feature_adaptation1.Rename)
  10094. closetTree (yyt->Feature_adaptation1.New_export)
  10095. closetTree (yyt->Feature_adaptation1.Undefine)
  10096. closetTree (yyt->Feature_adaptation1.Redefine)
  10097. closetTree (yyt->Feature_adaptation1.Select)
  10098. break;
  10099. case kRename_list1:
  10100. closetTree (yyt->Rename_list1.Rename_pair)
  10101. closetTree (yyt->Rename_list1.Rename_list)
  10102. break;
  10103. case kRename_pair:
  10104. closetTree (yyt->Rename_pair.Name1)
  10105. closetTree (yyt->Rename_pair.Name2)
  10106. break;
  10107. case kCreators1:
  10108. closetTree (yyt->Creators1.Creation_clause)
  10109. closetTree (yyt->Creators1.Creators)
  10110. break;
  10111. case kCreation_clause:
  10112. closetTree (yyt->Creation_clause.Clients)
  10113. closetTree (yyt->Creation_clause.Feature_list)
  10114. break;
  10115. case kNew_feature_list1:
  10116. closetTree (yyt->New_feature_list1.Feature_name)
  10117. closetTree (yyt->New_feature_list1.New_feature_list)
  10118. break;
  10119. case kFrozen:
  10120. closetTree (yyt->Frozen.Feature_name)
  10121. break;
  10122. case kIdent_name:
  10123. closetTree (yyt->Ident_name.Id)
  10124. break;
  10125. case kPrefix:
  10126. closetTree (yyt->Prefix.Op_name)
  10127. break;
  10128. case kInfix:
  10129. closetTree (yyt->Infix.Op_name)
  10130. break;
  10131. case kNew_export_list1:
  10132. closetTree (yyt->New_export_list1.New_export_item)
  10133. closetTree (yyt->New_export_list1.New_export_list)
  10134. break;
  10135. case kNew_export_item:
  10136. closetTree (yyt->New_export_item.Clients)
  10137. closetTree (yyt->New_export_item.Feature_set)
  10138. break;
  10139. case kFeature_list1:
  10140. closetTree (yyt->Feature_list1.Feature_name)
  10141. closetTree (yyt->Feature_list1.Feature_list)
  10142. break;
  10143. case kFormal_args1:
  10144. closetTree (yyt->Formal_args1.Entity_decl_group)
  10145. closetTree (yyt->Formal_args1.Formal_args)
  10146. break;
  10147. case kDo_body:
  10148. closetTree (yyt->Do_body.Compound)
  10149. break;
  10150. case kOnce_body:
  10151. closetTree (yyt->Once_body.Compound)
  10152. break;
  10153. case kExternal:
  10154. closetTree (yyt->External.Lang1)
  10155. closetTree (yyt->External.Lang2)
  10156. break;
  10157. case kEntity_decl_group:
  10158. closetTree (yyt->Entity_decl_group.Id_list)
  10159. closetTree (yyt->Entity_decl_group.Type_mark)
  10160. break;
  10161. case kFormal_generics1:
  10162. closetTree (yyt->Formal_generics1.Formal_generic)
  10163. closetTree (yyt->Formal_generics1.Formal_generics)
  10164. break;
  10165. case kFormal_generic:
  10166. closetTree (yyt->Formal_generic.Id)
  10167. closetTree (yyt->Formal_generic.Constraint)
  10168. break;
  10169. case kConstraint1:
  10170. closetTree (yyt->Constraint1.Class_type)
  10171. break;
  10172. case kCompound1:
  10173. closetTree (yyt->Compound1.Instruction)
  10174. closetTree (yyt->Compound1.Compound)
  10175. break;
  10176. case kThen_part_list1:
  10177. closetTree (yyt->Then_part_list1.Then_part)
  10178. closetTree (yyt->Then_part_list1.Then_part_list)
  10179. break;
  10180. case kThen_part:
  10181. closetTree (yyt->Then_part.Guard)
  10182. closetTree (yyt->Then_part.Compound)
  10183. break;
  10184. case kWhen_part_list1:
  10185. closetTree (yyt->When_part_list1.When_part)
  10186. closetTree (yyt->When_part_list1.When_part_list)
  10187. break;
  10188. case kWhen_part:
  10189. closetTree (yyt->When_part.Choices)
  10190. closetTree (yyt->When_part.Compound)
  10191. break;
  10192. case kChoices1:
  10193. closetTree (yyt->Choices1.Choice)
  10194. closetTree (yyt->Choices1.Choices)
  10195. break;
  10196. case kInterval:
  10197. closetTree (yyt->Interval.From)
  10198. closetTree (yyt->Interval.To)
  10199. break;
  10200. case kVal:
  10201. closetTree (yyt->Val.Manifest_constant)
  10202. break;
  10203. case kCreation:
  10204. closetTree (yyt->Creation.Type)
  10205. closetTree (yyt->Creation.Entity)
  10206. closetTree (yyt->Creation.Unqual_call)
  10207. break;
  10208. case kCall_instruct:
  10209. closetTree (yyt->Call_instruct.Call)
  10210. break;
  10211. case kAssign:
  10212. closetTree (yyt->Assign.Addr)
  10213. closetTree (yyt->Assign.Expression)
  10214. break;
  10215. case kRev_assign:
  10216. closetTree (yyt->Rev_assign.Addr)
  10217. closetTree (yyt->Rev_assign.Expression)
  10218. break;
  10219. case kConditional:
  10220. closetTree (yyt->Conditional.Then_part)
  10221. closetTree (yyt->Conditional.Else_part)
  10222. break;
  10223. case kMulti_branch:
  10224. closetTree (yyt->Multi_branch.Guard)
  10225. closetTree (yyt->Multi_branch.When_part_list)
  10226. closetTree (yyt->Multi_branch.Else_part)
  10227. break;
  10228. case kLoop:
  10229. closetTree (yyt->Loop.Initialization)
  10230. closetTree (yyt->Loop.Invariant)
  10231. closetTree (yyt->Loop.Variant)
  10232. closetTree (yyt->Loop.Loop_body)
  10233. break;
  10234. case kCheck:
  10235. closetTree (yyt->Check.Assertion)
  10236. break;
  10237. case kDebug:
  10238. closetTree (yyt->Debug.Debug_keys)
  10239. closetTree (yyt->Debug.Compound)
  10240. break;
  10241. case kLoop_body1:
  10242. closetTree (yyt->Loop_body1.Exit)
  10243. closetTree (yyt->Loop_body1.Compound)
  10244. break;
  10245. case kClass_type:
  10246. closetTree (yyt->Class_type.Id)
  10247. closetTree (yyt->Class_type.Actual_generics)
  10248. break;
  10249. case kClass_type_expanded:
  10250. closetTree (yyt->Class_type_expanded.Id)
  10251. closetTree (yyt->Class_type_expanded.Actual_generics)
  10252. break;
  10253. case kBit_type:
  10254. closetTree (yyt->Bit_type.Manifest_constant)
  10255. break;
  10256. case kSimple_type:
  10257. closetTree (yyt->Simple_type.Manifest_constant)
  10258. break;
  10259. case kAnchored:
  10260. closetTree (yyt->Anchored.Entity)
  10261. break;
  10262. case kActual_generics1:
  10263. closetTree (yyt->Actual_generics1.Type_list)
  10264. break;
  10265. case kCondition1:
  10266. closetTree (yyt->Condition1.Assertion)
  10267. break;
  10268. case kAssertion1:
  10269. closetTree (yyt->Assertion1.Assertion_clause)
  10270. closetTree (yyt->Assertion1.Assertion)
  10271. break;
  10272. case kAssertion_clause1:
  10273. closetTree (yyt->Assertion_clause1.Tag)
  10274. closetTree (yyt->Assertion_clause1.Expression)
  10275. break;
  10276. case kType_list1:
  10277. closetTree (yyt->Type_list1.Type)
  10278. closetTree (yyt->Type_list1.Type_list)
  10279. break;
  10280. case kCall_chain1:
  10281. closetTree (yyt->Call_chain1.Unqual_call)
  10282. closetTree (yyt->Call_chain1.Call_chain)
  10283. break;
  10284. case kUnqual_call1:
  10285. closetTree (yyt->Unqual_call1.Entity)
  10286. closetTree (yyt->Unqual_call1.Actuals)
  10287. break;
  10288. case kActuals1:
  10289. closetTree (yyt->Actuals1.Actual_list)
  10290. break;
  10291. case kActual_list1:
  10292. closetTree (yyt->Actual_list1.Actual)
  10293. closetTree (yyt->Actual_list1.Actual_list)
  10294. break;
  10295. case kAddr:
  10296. closetTree (yyt->Addr.Entity)
  10297. break;
  10298. case kSimple_expr:
  10299. closetTree (yyt->Simple_expr.Manifest_constant)
  10300. break;
  10301. case kCall:
  10302. closetTree (yyt->Call.Qual)
  10303. closetTree (yyt->Call.Call_chain)
  10304. break;
  10305. case kBin_expr:
  10306. closetTree (yyt->Bin_expr.Lop)
  10307. closetTree (yyt->Bin_expr.Op)
  10308. closetTree (yyt->Bin_expr.Rop)
  10309. break;
  10310. case kUn_expr:
  10311. closetTree (yyt->Un_expr.Op)
  10312. closetTree (yyt->Un_expr.Expression)
  10313. break;
  10314. case kParenth:
  10315. closetTree (yyt->Parenth.Expression)
  10316. break;
  10317. case kManifest_array1:
  10318. closetTree (yyt->Manifest_array1.Expression)
  10319. closetTree (yyt->Manifest_array1.Manifest_array)
  10320. break;
  10321. case kOld:
  10322. closetTree (yyt->Old.Expression)
  10323. break;
  10324. case kStrip:
  10325. closetTree (yyt->Strip.List)
  10326. break;
  10327. case klist:
  10328. closetTree (yyt->list.Manifest_constant)
  10329. closetTree (yyt->list.List)
  10330. break;
  10331. case kInt:
  10332. closetTree (yyt->Int.Sign)
  10333. break;
  10334. case kReal:
  10335. closetTree (yyt->Real.Sign)
  10336. break;
  10337.  default: ;
  10338.  }
  10339.  
  10340.  if (-- yyt->yyHead.yyMark == 0) {
  10341.   switch (yyt->Kind) {
  10342. case kClass_declaration:
  10343. closetStringRef (yyt->Class_declaration.comment)
  10344. break;
  10345. case kFeature_clause:
  10346. closetStringRef (yyt->Feature_clause.comment)
  10347. break;
  10348. case kUnique:
  10349. closetPosition (yyt->Unique.pos)
  10350. break;
  10351. case kRoutine:
  10352. closetStringRef (yyt->Routine.comment)
  10353. closetStringRef (yyt->Routine.end_comment)
  10354. break;
  10355. case kCreation_clause:
  10356. closetStringRef (yyt->Creation_clause.comment)
  10357. break;
  10358. case kOp_name:
  10359. closetPosition (yyt->Op_name.pos)
  10360. break;
  10361. case kFree_op:
  10362. closetPosition (yyt->Free_op.pos)
  10363. closetIdent (yyt->Free_op.ident)
  10364. break;
  10365. case kOper:
  10366. closetPosition (yyt->Oper.pos)
  10367. closeint (yyt->Oper.op)
  10368. break;
  10369. case kDeferred:
  10370. closetPosition (yyt->Deferred.pos)
  10371. break;
  10372. case kRetry:
  10373. closetPosition (yyt->Retry.pos)
  10374. break;
  10375. case kCondition1:
  10376. closeint (yyt->Condition1.extension)
  10377. break;
  10378. case kComment:
  10379. closetStringRef (yyt->Comment.comment)
  10380. break;
  10381. case kCh:
  10382. closeint (yyt->Ch.ch)
  10383. closetPosition (yyt->Ch.pos)
  10384. break;
  10385. case kTrue:
  10386. closetPosition (yyt->True.pos)
  10387. break;
  10388. case kFalse:
  10389. closetPosition (yyt->False.pos)
  10390. break;
  10391. case kInt:
  10392. closelong (yyt->Int.value)
  10393. closetPosition (yyt->Int.pos)
  10394. break;
  10395. case kReal:
  10396. closedouble (yyt->Real.value)
  10397. closetPosition (yyt->Real.pos)
  10398. break;
  10399. case k_CHARACTER:
  10400. closetPosition (yyt->_CHARACTER.pos)
  10401. break;
  10402. case k_INTEGER:
  10403. closetPosition (yyt->_INTEGER.pos)
  10404. break;
  10405. case k_REAL:
  10406. closetPosition (yyt->_REAL.pos)
  10407. break;
  10408. case k_DOUBLE:
  10409. closetPosition (yyt->_DOUBLE.pos)
  10410. break;
  10411. case k_BOOLEAN:
  10412. closetPosition (yyt->_BOOLEAN.pos)
  10413. break;
  10414. case k_STRING:
  10415. closetPosition (yyt->_STRING.pos)
  10416. break;
  10417. case k_BIT:
  10418. closetPosition (yyt->_BIT.pos)
  10419. break;
  10420. case k_NONE:
  10421. closetPosition (yyt->_NONE.pos)
  10422. break;
  10423. case kBitseq:
  10424. closetStringRef (yyt->Bitseq.literal)
  10425. closetPosition (yyt->Bitseq.pos)
  10426. break;
  10427. case kString:
  10428. closetStringRef (yyt->String.string)
  10429. closetPosition (yyt->String.pos)
  10430. break;
  10431. case kCurrent:
  10432. closetPosition (yyt->Current.pos)
  10433. break;
  10434. case kResult:
  10435. closetPosition (yyt->Result.pos)
  10436. break;
  10437. case kId:
  10438. closetIdent (yyt->Id.ident)
  10439. closetPosition (yyt->Id.pos)
  10440. break;
  10441.   default: ;
  10442.   }
  10443.   yyFREE (yyt, Tree_NodeSize [yyt->Kind])
  10444.  }
  10445. }
  10446.  
  10447. void ReleaseTree
  10448. # if defined __STDC__ | defined __cplusplus
  10449.  (tTree yyt)
  10450. # else
  10451.  (yyt) tTree yyt;
  10452. # endif
  10453. {
  10454.  yyMark (yyt);
  10455.  yyReleaseTree (yyt);
  10456. }
  10457.  
  10458. void ReleaseTreeModule ()
  10459. {
  10460.  yytBlockPtr yyBlockPtr;
  10461.  while (yyBlockList != (yytBlockPtr) NoTree) {
  10462.   yyBlockPtr = yyBlockList;
  10463.   yyBlockList = yyBlockList->yySuccessor;
  10464.   Free (sizeof (yytBlock), (char *) yyBlockPtr);
  10465.  }
  10466.  Tree_PoolFreePtr = (char *) NoTree;
  10467.  Tree_PoolMaxPtr = (char *) NoTree;
  10468.  Tree_HeapUsed = 0;
  10469. }
  10470.  
  10471. static Tree_tProcTree yyProc;
  10472.  
  10473. static void yyTraverseTreeTD
  10474. # if defined __STDC__ | defined __cplusplus
  10475.  (tTree yyt)
  10476. # else
  10477.  (yyt) tTree yyt;
  10478. # endif
  10479. {
  10480.  for (;;) {
  10481.   if (yyt == NoTree || yyt->yyHead.yyMark == 0) return;
  10482.   yyt->yyHead.yyMark = 0;
  10483.   yyProc (yyt);
  10484.  
  10485.   switch (yyt->Kind) {
  10486. case kEiffel:
  10487. yyt = yyt->Eiffel.Classes; break;
  10488. case kClasses1:
  10489. yyTraverseTreeTD (yyt->Classes1.Class_declaration);
  10490. yyt = yyt->Classes1.Classes; break;
  10491. case kClass_declaration:
  10492. yyTraverseTreeTD (yyt->Class_declaration.Indexing);
  10493. yyTraverseTreeTD (yyt->Class_declaration.Class_header);
  10494. yyTraverseTreeTD (yyt->Class_declaration.Formal_generics);
  10495. yyTraverseTreeTD (yyt->Class_declaration.Obsolete);
  10496. yyTraverseTreeTD (yyt->Class_declaration.Inheritance);
  10497. yyTraverseTreeTD (yyt->Class_declaration.Creators);
  10498. yyTraverseTreeTD (yyt->Class_declaration.Features);
  10499. yyt = yyt->Class_declaration.Invariant; break;
  10500. case kIndex_list1:
  10501. yyTraverseTreeTD (yyt->Index_list1.Index_clause);
  10502. yyt = yyt->Index_list1.Index_list; break;
  10503. case kIndex_clause:
  10504. yyTraverseTreeTD (yyt->Index_clause.Index);
  10505. yyt = yyt->Index_clause.Index_terms; break;
  10506. case kClass:
  10507. yyt = yyt->Class.Name; break;
  10508. case kExpanded_class:
  10509. yyt = yyt->Expanded_class.Name; break;
  10510. case kDeferred_class:
  10511. yyt = yyt->Deferred_class.Name; break;
  10512. case kFeatures1:
  10513. yyTraverseTreeTD (yyt->Features1.Feature_clause);
  10514. yyt = yyt->Features1.Features; break;
  10515. case kFeature_clause:
  10516. yyTraverseTreeTD (yyt->Feature_clause.Clients);
  10517. yyt = yyt->Feature_clause.Feature_decls; break;
  10518. case kClients1:
  10519. yyt = yyt->Clients1.List; break;
  10520. case kFeature_decls1:
  10521. yyTraverseTreeTD (yyt->Feature_decls1.Feature_decl);
  10522. yyt = yyt->Feature_decls1.Feature_decls; break;
  10523. case kFeature_decl:
  10524. yyTraverseTreeTD (yyt->Feature_decl.New_feature_list);
  10525. yyt = yyt->Feature_decl.Declaration_body; break;
  10526. case kDeclaration_body:
  10527. yyTraverseTreeTD (yyt->Declaration_body.Formal_args);
  10528. yyTraverseTreeTD (yyt->Declaration_body.Type_mark);
  10529. yyt = yyt->Declaration_body.Const_or_routine; break;
  10530. case kM_const:
  10531. yyt = yyt->M_const.Manifest_constant; break;
  10532. case kRoutine:
  10533. yyTraverseTreeTD (yyt->Routine.Obsolete);
  10534. yyTraverseTreeTD (yyt->Routine.Precondition);
  10535. yyTraverseTreeTD (yyt->Routine.Local_decls);
  10536. yyTraverseTreeTD (yyt->Routine.Routine_body);
  10537. yyTraverseTreeTD (yyt->Routine.Postcondition);
  10538. yyt = yyt->Routine.Rescue; break;
  10539. case kParent_list1:
  10540. yyTraverseTreeTD (yyt->Parent_list1.Parent);
  10541. yyt = yyt->Parent_list1.Parent_list; break;
  10542. case kParent:
  10543. yyTraverseTreeTD (yyt->Parent.Class_type);
  10544. yyt = yyt->Parent.Feature_adaptation; break;
  10545. case kFeature_adaptation1:
  10546. yyTraverseTreeTD (yyt->Feature_adaptation1.Rename);
  10547. yyTraverseTreeTD (yyt->Feature_adaptation1.New_export);
  10548. yyTraverseTreeTD (yyt->Feature_adaptation1.Undefine);
  10549. yyTraverseTreeTD (yyt->Feature_adaptation1.Redefine);
  10550. yyt = yyt->Feature_adaptation1.Select; break;
  10551. case kRename_list1:
  10552. yyTraverseTreeTD (yyt->Rename_list1.Rename_pair);
  10553. yyt = yyt->Rename_list1.Rename_list; break;
  10554. case kRename_pair:
  10555. yyTraverseTreeTD (yyt->Rename_pair.Name1);
  10556. yyt = yyt->Rename_pair.Name2; break;
  10557. case kCreators1:
  10558. yyTraverseTreeTD (yyt->Creators1.Creation_clause);
  10559. yyt = yyt->Creators1.Creators; break;
  10560. case kCreation_clause:
  10561. yyTraverseTreeTD (yyt->Creation_clause.Clients);
  10562. yyt = yyt->Creation_clause.Feature_list; break;
  10563. case kNew_feature_list1:
  10564. yyTraverseTreeTD (yyt->New_feature_list1.Feature_name);
  10565. yyt = yyt->New_feature_list1.New_feature_list; break;
  10566. case kFrozen:
  10567. yyt = yyt->Frozen.Feature_name; break;
  10568. case kIdent_name:
  10569. yyt = yyt->Ident_name.Id; break;
  10570. case kPrefix:
  10571. yyt = yyt->Prefix.Op_name; break;
  10572. case kInfix:
  10573. yyt = yyt->Infix.Op_name; break;
  10574. case kNew_export_list1:
  10575. yyTraverseTreeTD (yyt->New_export_list1.New_export_item);
  10576. yyt = yyt->New_export_list1.New_export_list; break;
  10577. case kNew_export_item:
  10578. yyTraverseTreeTD (yyt->New_export_item.Clients);
  10579. yyt = yyt->New_export_item.Feature_set; break;
  10580. case kFeature_list1:
  10581. yyTraverseTreeTD (yyt->Feature_list1.Feature_name);
  10582. yyt = yyt->Feature_list1.Feature_list; break;
  10583. case kFormal_args1:
  10584. yyTraverseTreeTD (yyt->Formal_args1.Entity_decl_group);
  10585. yyt = yyt->Formal_args1.Formal_args; break;
  10586. case kDo_body:
  10587. yyt = yyt->Do_body.Compound; break;
  10588. case kOnce_body:
  10589. yyt = yyt->Once_body.Compound; break;
  10590. case kExternal:
  10591. yyTraverseTreeTD (yyt->External.Lang1);
  10592. yyt = yyt->External.Lang2; break;
  10593. case kEntity_decl_group:
  10594. yyTraverseTreeTD (yyt->Entity_decl_group.Id_list);
  10595. yyt = yyt->Entity_decl_group.Type_mark; break;
  10596. case kFormal_generics1:
  10597. yyTraverseTreeTD (yyt->Formal_generics1.Formal_generic);
  10598. yyt = yyt->Formal_generics1.Formal_generics; break;
  10599. case kFormal_generic:
  10600. yyTraverseTreeTD (yyt->Formal_generic.Id);
  10601. yyt = yyt->Formal_generic.Constraint; break;
  10602. case kConstraint1:
  10603. yyt = yyt->Constraint1.Class_type; break;
  10604. case kCompound1:
  10605. yyTraverseTreeTD (yyt->Compound1.Instruction);
  10606. yyt = yyt->Compound1.Compound; break;
  10607. case kThen_part_list1:
  10608. yyTraverseTreeTD (yyt->Then_part_list1.Then_part);
  10609. yyt = yyt->Then_part_list1.Then_part_list; break;
  10610. case kThen_part:
  10611. yyTraverseTreeTD (yyt->Then_part.Guard);
  10612. yyt = yyt->Then_part.Compound; break;
  10613. case kWhen_part_list1:
  10614. yyTraverseTreeTD (yyt->When_part_list1.When_part);
  10615. yyt = yyt->When_part_list1.When_part_list; break;
  10616. case kWhen_part:
  10617. yyTraverseTreeTD (yyt->When_part.Choices);
  10618. yyt = yyt->When_part.Compound; break;
  10619. case kChoices1:
  10620. yyTraverseTreeTD (yyt->Choices1.Choice);
  10621. yyt = yyt->Choices1.Choices; break;
  10622. case kInterval:
  10623. yyTraverseTreeTD (yyt->Interval.From);
  10624. yyt = yyt->Interval.To; break;
  10625. case kVal:
  10626. yyt = yyt->Val.Manifest_constant; break;
  10627. case kCreation:
  10628. yyTraverseTreeTD (yyt->Creation.Type);
  10629. yyTraverseTreeTD (yyt->Creation.Entity);
  10630. yyt = yyt->Creation.Unqual_call; break;
  10631. case kCall_instruct:
  10632. yyt = yyt->Call_instruct.Call; break;
  10633. case kAssign:
  10634. yyTraverseTreeTD (yyt->Assign.Addr);
  10635. yyt = yyt->Assign.Expression; break;
  10636. case kRev_assign:
  10637. yyTraverseTreeTD (yyt->Rev_assign.Addr);
  10638. yyt = yyt->Rev_assign.Expression; break;
  10639. case kConditional:
  10640. yyTraverseTreeTD (yyt->Conditional.Then_part);
  10641. yyt = yyt->Conditional.Else_part; break;
  10642. case kMulti_branch:
  10643. yyTraverseTreeTD (yyt->Multi_branch.Guard);
  10644. yyTraverseTreeTD (yyt->Multi_branch.When_part_list);
  10645. yyt = yyt->Multi_branch.Else_part; break;
  10646. case kLoop:
  10647. yyTraverseTreeTD (yyt->Loop.Initialization);
  10648. yyTraverseTreeTD (yyt->Loop.Invariant);
  10649. yyTraverseTreeTD (yyt->Loop.Variant);
  10650. yyt = yyt->Loop.Loop_body; break;
  10651. case kCheck:
  10652. yyt = yyt->Check.Assertion; break;
  10653. case kDebug:
  10654. yyTraverseTreeTD (yyt->Debug.Debug_keys);
  10655. yyt = yyt->Debug.Compound; break;
  10656. case kLoop_body1:
  10657. yyTraverseTreeTD (yyt->Loop_body1.Exit);
  10658. yyt = yyt->Loop_body1.Compound; break;
  10659. case kClass_type:
  10660. yyTraverseTreeTD (yyt->Class_type.Id);
  10661. yyt = yyt->Class_type.Actual_generics; break;
  10662. case kClass_type_expanded:
  10663. yyTraverseTreeTD (yyt->Class_type_expanded.Id);
  10664. yyt = yyt->Class_type_expanded.Actual_generics; break;
  10665. case kBit_type:
  10666. yyt = yyt->Bit_type.Manifest_constant; break;
  10667. case kSimple_type:
  10668. yyt = yyt->Simple_type.Manifest_constant; break;
  10669. case kAnchored:
  10670. yyt = yyt->Anchored.Entity; break;
  10671. case kActual_generics1:
  10672. yyt = yyt->Actual_generics1.Type_list; break;
  10673. case kCondition1:
  10674. yyt = yyt->Condition1.Assertion; break;
  10675. case kAssertion1:
  10676. yyTraverseTreeTD (yyt->Assertion1.Assertion_clause);
  10677. yyt = yyt->Assertion1.Assertion; break;
  10678. case kAssertion_clause1:
  10679. yyTraverseTreeTD (yyt->Assertion_clause1.Tag);
  10680. yyt = yyt->Assertion_clause1.Expression; break;
  10681. case kType_list1:
  10682. yyTraverseTreeTD (yyt->Type_list1.Type);
  10683. yyt = yyt->Type_list1.Type_list; break;
  10684. case kCall_chain1:
  10685. yyTraverseTreeTD (yyt->Call_chain1.Unqual_call);
  10686. yyt = yyt->Call_chain1.Call_chain; break;
  10687. case kUnqual_call1:
  10688. yyTraverseTreeTD (yyt->Unqual_call1.Entity);
  10689. yyt = yyt->Unqual_call1.Actuals; break;
  10690. case kActuals1:
  10691. yyt = yyt->Actuals1.Actual_list; break;
  10692. case kActual_list1:
  10693. yyTraverseTreeTD (yyt->Actual_list1.Actual);
  10694. yyt = yyt->Actual_list1.Actual_list; break;
  10695. case kAddr:
  10696. yyt = yyt->Addr.Entity; break;
  10697. case kSimple_expr:
  10698. yyt = yyt->Simple_expr.Manifest_constant; break;
  10699. case kCall:
  10700. yyTraverseTreeTD (yyt->Call.Qual);
  10701. yyt = yyt->Call.Call_chain; break;
  10702. case kBin_expr:
  10703. yyTraverseTreeTD (yyt->Bin_expr.Lop);
  10704. yyTraverseTreeTD (yyt->Bin_expr.Op);
  10705. yyt = yyt->Bin_expr.Rop; break;
  10706. case kUn_expr:
  10707. yyTraverseTreeTD (yyt->Un_expr.Op);
  10708. yyt = yyt->Un_expr.Expression; break;
  10709. case kParenth:
  10710. yyt = yyt->Parenth.Expression; break;
  10711. case kManifest_array1:
  10712. yyTraverseTreeTD (yyt->Manifest_array1.Expression);
  10713. yyt = yyt->Manifest_array1.Manifest_array; break;
  10714. case kOld:
  10715. yyt = yyt->Old.Expression; break;
  10716. case kStrip:
  10717. yyt = yyt->Strip.List; break;
  10718. case klist:
  10719. yyTraverseTreeTD (yyt->list.Manifest_constant);
  10720. yyt = yyt->list.List; break;
  10721. case kInt:
  10722. yyt = yyt->Int.Sign; break;
  10723. case kReal:
  10724. yyt = yyt->Real.Sign; break;
  10725.   default: return;
  10726.   }
  10727.  }
  10728. }
  10729.  
  10730. void TraverseTreeTD
  10731. # if defined __STDC__ | defined __cplusplus
  10732.  (tTree yyt, Tree_tProcTree yyyProc)
  10733. # else
  10734.  (yyt, yyyProc) tTree yyt; Tree_tProcTree yyyProc;
  10735. # endif
  10736. {
  10737.  yyMark (yyt);
  10738.  yyProc = yyyProc;
  10739.  yyTraverseTreeTD (yyt);
  10740. }
  10741.  
  10742. static void yyTraverseTreeBU
  10743. # if defined __STDC__ | defined __cplusplus
  10744.  (tTree yyt)
  10745. # else
  10746.  (yyt) tTree yyt;
  10747. # endif
  10748. {
  10749.  if (yyt == NoTree || yyt->yyHead.yyMark == 0) return;
  10750.  yyt->yyHead.yyMark = 0;
  10751.  
  10752.  switch (yyt->Kind) {
  10753. case kEiffel:
  10754. yyTraverseTreeBU (yyt->Eiffel.Classes); break;
  10755. case kClasses1:
  10756. yyTraverseTreeBU (yyt->Classes1.Class_declaration);
  10757. yyTraverseTreeBU (yyt->Classes1.Classes); break;
  10758. case kClass_declaration:
  10759. yyTraverseTreeBU (yyt->Class_declaration.Indexing);
  10760. yyTraverseTreeBU (yyt->Class_declaration.Class_header);
  10761. yyTraverseTreeBU (yyt->Class_declaration.Formal_generics);
  10762. yyTraverseTreeBU (yyt->Class_declaration.Obsolete);
  10763. yyTraverseTreeBU (yyt->Class_declaration.Inheritance);
  10764. yyTraverseTreeBU (yyt->Class_declaration.Creators);
  10765. yyTraverseTreeBU (yyt->Class_declaration.Features);
  10766. yyTraverseTreeBU (yyt->Class_declaration.Invariant); break;
  10767. case kIndex_list1:
  10768. yyTraverseTreeBU (yyt->Index_list1.Index_clause);
  10769. yyTraverseTreeBU (yyt->Index_list1.Index_list); break;
  10770. case kIndex_clause:
  10771. yyTraverseTreeBU (yyt->Index_clause.Index);
  10772. yyTraverseTreeBU (yyt->Index_clause.Index_terms); break;
  10773. case kClass:
  10774. yyTraverseTreeBU (yyt->Class.Name); break;
  10775. case kExpanded_class:
  10776. yyTraverseTreeBU (yyt->Expanded_class.Name); break;
  10777. case kDeferred_class:
  10778. yyTraverseTreeBU (yyt->Deferred_class.Name); break;
  10779. case kFeatures1:
  10780. yyTraverseTreeBU (yyt->Features1.Feature_clause);
  10781. yyTraverseTreeBU (yyt->Features1.Features); break;
  10782. case kFeature_clause:
  10783. yyTraverseTreeBU (yyt->Feature_clause.Clients);
  10784. yyTraverseTreeBU (yyt->Feature_clause.Feature_decls); break;
  10785. case kClients1:
  10786. yyTraverseTreeBU (yyt->Clients1.List); break;
  10787. case kFeature_decls1:
  10788. yyTraverseTreeBU (yyt->Feature_decls1.Feature_decl);
  10789. yyTraverseTreeBU (yyt->Feature_decls1.Feature_decls); break;
  10790. case kFeature_decl:
  10791. yyTraverseTreeBU (yyt->Feature_decl.New_feature_list);
  10792. yyTraverseTreeBU (yyt->Feature_decl.Declaration_body); break;
  10793. case kDeclaration_body:
  10794. yyTraverseTreeBU (yyt->Declaration_body.Formal_args);
  10795. yyTraverseTreeBU (yyt->Declaration_body.Type_mark);
  10796. yyTraverseTreeBU (yyt->Declaration_body.Const_or_routine); break;
  10797. case kM_const:
  10798. yyTraverseTreeBU (yyt->M_const.Manifest_constant); break;
  10799. case kRoutine:
  10800. yyTraverseTreeBU (yyt->Routine.Obsolete);
  10801. yyTraverseTreeBU (yyt->Routine.Precondition);
  10802. yyTraverseTreeBU (yyt->Routine.Local_decls);
  10803. yyTraverseTreeBU (yyt->Routine.Routine_body);
  10804. yyTraverseTreeBU (yyt->Routine.Postcondition);
  10805. yyTraverseTreeBU (yyt->Routine.Rescue); break;
  10806. case kParent_list1:
  10807. yyTraverseTreeBU (yyt->Parent_list1.Parent);
  10808. yyTraverseTreeBU (yyt->Parent_list1.Parent_list); break;
  10809. case kParent:
  10810. yyTraverseTreeBU (yyt->Parent.Class_type);
  10811. yyTraverseTreeBU (yyt->Parent.Feature_adaptation); break;
  10812. case kFeature_adaptation1:
  10813. yyTraverseTreeBU (yyt->Feature_adaptation1.Rename);
  10814. yyTraverseTreeBU (yyt->Feature_adaptation1.New_export);
  10815. yyTraverseTreeBU (yyt->Feature_adaptation1.Undefine);
  10816. yyTraverseTreeBU (yyt->Feature_adaptation1.Redefine);
  10817. yyTraverseTreeBU (yyt->Feature_adaptation1.Select); break;
  10818. case kRename_list1:
  10819. yyTraverseTreeBU (yyt->Rename_list1.Rename_pair);
  10820. yyTraverseTreeBU (yyt->Rename_list1.Rename_list); break;
  10821. case kRename_pair:
  10822. yyTraverseTreeBU (yyt->Rename_pair.Name1);
  10823. yyTraverseTreeBU (yyt->Rename_pair.Name2); break;
  10824. case kCreators1:
  10825. yyTraverseTreeBU (yyt->Creators1.Creation_clause);
  10826. yyTraverseTreeBU (yyt->Creators1.Creators); break;
  10827. case kCreation_clause:
  10828. yyTraverseTreeBU (yyt->Creation_clause.Clients);
  10829. yyTraverseTreeBU (yyt->Creation_clause.Feature_list); break;
  10830. case kNew_feature_list1:
  10831. yyTraverseTreeBU (yyt->New_feature_list1.Feature_name);
  10832. yyTraverseTreeBU (yyt->New_feature_list1.New_feature_list); break;
  10833. case kFrozen:
  10834. yyTraverseTreeBU (yyt->Frozen.Feature_name); break;
  10835. case kIdent_name:
  10836. yyTraverseTreeBU (yyt->Ident_name.Id); break;
  10837. case kPrefix:
  10838. yyTraverseTreeBU (yyt->Prefix.Op_name); break;
  10839. case kInfix:
  10840. yyTraverseTreeBU (yyt->Infix.Op_name); break;
  10841. case kNew_export_list1:
  10842. yyTraverseTreeBU (yyt->New_export_list1.New_export_item);
  10843. yyTraverseTreeBU (yyt->New_export_list1.New_export_list); break;
  10844. case kNew_export_item:
  10845. yyTraverseTreeBU (yyt->New_export_item.Clients);
  10846. yyTraverseTreeBU (yyt->New_export_item.Feature_set); break;
  10847. case kFeature_list1:
  10848. yyTraverseTreeBU (yyt->Feature_list1.Feature_name);
  10849. yyTraverseTreeBU (yyt->Feature_list1.Feature_list); break;
  10850. case kFormal_args1:
  10851. yyTraverseTreeBU (yyt->Formal_args1.Entity_decl_group);
  10852. yyTraverseTreeBU (yyt->Formal_args1.Formal_args); break;
  10853. case kDo_body:
  10854. yyTraverseTreeBU (yyt->Do_body.Compound); break;
  10855. case kOnce_body:
  10856. yyTraverseTreeBU (yyt->Once_body.Compound); break;
  10857. case kExternal:
  10858. yyTraverseTreeBU (yyt->External.Lang1);
  10859. yyTraverseTreeBU (yyt->External.Lang2); break;
  10860. case kEntity_decl_group:
  10861. yyTraverseTreeBU (yyt->Entity_decl_group.Id_list);
  10862. yyTraverseTreeBU (yyt->Entity_decl_group.Type_mark); break;
  10863. case kFormal_generics1:
  10864. yyTraverseTreeBU (yyt->Formal_generics1.Formal_generic);
  10865. yyTraverseTreeBU (yyt->Formal_generics1.Formal_generics); break;
  10866. case kFormal_generic:
  10867. yyTraverseTreeBU (yyt->Formal_generic.Id);
  10868. yyTraverseTreeBU (yyt->Formal_generic.Constraint); break;
  10869. case kConstraint1:
  10870. yyTraverseTreeBU (yyt->Constraint1.Class_type); break;
  10871. case kCompound1:
  10872. yyTraverseTreeBU (yyt->Compound1.Instruction);
  10873. yyTraverseTreeBU (yyt->Compound1.Compound); break;
  10874. case kThen_part_list1:
  10875. yyTraverseTreeBU (yyt->Then_part_list1.Then_part);
  10876. yyTraverseTreeBU (yyt->Then_part_list1.Then_part_list); break;
  10877. case kThen_part:
  10878. yyTraverseTreeBU (yyt->Then_part.Guard);
  10879. yyTraverseTreeBU (yyt->Then_part.Compound); break;
  10880. case kWhen_part_list1:
  10881. yyTraverseTreeBU (yyt->When_part_list1.When_part);
  10882. yyTraverseTreeBU (yyt->When_part_list1.When_part_list); break;
  10883. case kWhen_part:
  10884. yyTraverseTreeBU (yyt->When_part.Choices);
  10885. yyTraverseTreeBU (yyt->When_part.Compound); break;
  10886. case kChoices1:
  10887. yyTraverseTreeBU (yyt->Choices1.Choice);
  10888. yyTraverseTreeBU (yyt->Choices1.Choices); break;
  10889. case kInterval:
  10890. yyTraverseTreeBU (yyt->Interval.From);
  10891. yyTraverseTreeBU (yyt->Interval.To); break;
  10892. case kVal:
  10893. yyTraverseTreeBU (yyt->Val.Manifest_constant); break;
  10894. case kCreation:
  10895. yyTraverseTreeBU (yyt->Creation.Type);
  10896. yyTraverseTreeBU (yyt->Creation.Entity);
  10897. yyTraverseTreeBU (yyt->Creation.Unqual_call); break;
  10898. case kCall_instruct:
  10899. yyTraverseTreeBU (yyt->Call_instruct.Call); break;
  10900. case kAssign:
  10901. yyTraverseTreeBU (yyt->Assign.Addr);
  10902. yyTraverseTreeBU (yyt->Assign.Expression); break;
  10903. case kRev_assign:
  10904. yyTraverseTreeBU (yyt->Rev_assign.Addr);
  10905. yyTraverseTreeBU (yyt->Rev_assign.Expression); break;
  10906. case kConditional:
  10907. yyTraverseTreeBU (yyt->Conditional.Then_part);
  10908. yyTraverseTreeBU (yyt->Conditional.Else_part); break;
  10909. case kMulti_branch:
  10910. yyTraverseTreeBU (yyt->Multi_branch.Guard);
  10911. yyTraverseTreeBU (yyt->Multi_branch.When_part_list);
  10912. yyTraverseTreeBU (yyt->Multi_branch.Else_part); break;
  10913. case kLoop:
  10914. yyTraverseTreeBU (yyt->Loop.Initialization);
  10915. yyTraverseTreeBU (yyt->Loop.Invariant);
  10916. yyTraverseTreeBU (yyt->Loop.Variant);
  10917. yyTraverseTreeBU (yyt->Loop.Loop_body); break;
  10918. case kCheck:
  10919. yyTraverseTreeBU (yyt->Check.Assertion); break;
  10920. case kDebug:
  10921. yyTraverseTreeBU (yyt->Debug.Debug_keys);
  10922. yyTraverseTreeBU (yyt->Debug.Compound); break;
  10923. case kLoop_body1:
  10924. yyTraverseTreeBU (yyt->Loop_body1.Exit);
  10925. yyTraverseTreeBU (yyt->Loop_body1.Compound); break;
  10926. case kClass_type:
  10927. yyTraverseTreeBU (yyt->Class_type.Id);
  10928. yyTraverseTreeBU (yyt->Class_type.Actual_generics); break;
  10929. case kClass_type_expanded:
  10930. yyTraverseTreeBU (yyt->Class_type_expanded.Id);
  10931. yyTraverseTreeBU (yyt->Class_type_expanded.Actual_generics); break;
  10932. case kBit_type:
  10933. yyTraverseTreeBU (yyt->Bit_type.Manifest_constant); break;
  10934. case kSimple_type:
  10935. yyTraverseTreeBU (yyt->Simple_type.Manifest_constant); break;
  10936. case kAnchored:
  10937. yyTraverseTreeBU (yyt->Anchored.Entity); break;
  10938. case kActual_generics1:
  10939. yyTraverseTreeBU (yyt->Actual_generics1.Type_list); break;
  10940. case kCondition1:
  10941. yyTraverseTreeBU (yyt->Condition1.Assertion); break;
  10942. case kAssertion1:
  10943. yyTraverseTreeBU (yyt->Assertion1.Assertion_clause);
  10944. yyTraverseTreeBU (yyt->Assertion1.Assertion); break;
  10945. case kAssertion_clause1:
  10946. yyTraverseTreeBU (yyt->Assertion_clause1.Tag);
  10947. yyTraverseTreeBU (yyt->Assertion_clause1.Expression); break;
  10948. case kType_list1:
  10949. yyTraverseTreeBU (yyt->Type_list1.Type);
  10950. yyTraverseTreeBU (yyt->Type_list1.Type_list); break;
  10951. case kCall_chain1:
  10952. yyTraverseTreeBU (yyt->Call_chain1.Unqual_call);
  10953. yyTraverseTreeBU (yyt->Call_chain1.Call_chain); break;
  10954. case kUnqual_call1:
  10955. yyTraverseTreeBU (yyt->Unqual_call1.Entity);
  10956. yyTraverseTreeBU (yyt->Unqual_call1.Actuals); break;
  10957. case kActuals1:
  10958. yyTraverseTreeBU (yyt->Actuals1.Actual_list); break;
  10959. case kActual_list1:
  10960. yyTraverseTreeBU (yyt->Actual_list1.Actual);
  10961. yyTraverseTreeBU (yyt->Actual_list1.Actual_list); break;
  10962. case kAddr:
  10963. yyTraverseTreeBU (yyt->Addr.Entity); break;
  10964. case kSimple_expr:
  10965. yyTraverseTreeBU (yyt->Simple_expr.Manifest_constant); break;
  10966. case kCall:
  10967. yyTraverseTreeBU (yyt->Call.Qual);
  10968. yyTraverseTreeBU (yyt->Call.Call_chain); break;
  10969. case kBin_expr:
  10970. yyTraverseTreeBU (yyt->Bin_expr.Lop);
  10971. yyTraverseTreeBU (yyt->Bin_expr.Op);
  10972. yyTraverseTreeBU (yyt->Bin_expr.Rop); break;
  10973. case kUn_expr:
  10974. yyTraverseTreeBU (yyt->Un_expr.Op);
  10975. yyTraverseTreeBU (yyt->Un_expr.Expression); break;
  10976. case kParenth:
  10977. yyTraverseTreeBU (yyt->Parenth.Expression); break;
  10978. case kManifest_array1:
  10979. yyTraverseTreeBU (yyt->Manifest_array1.Expression);
  10980. yyTraverseTreeBU (yyt->Manifest_array1.Manifest_array); break;
  10981. case kOld:
  10982. yyTraverseTreeBU (yyt->Old.Expression); break;
  10983. case kStrip:
  10984. yyTraverseTreeBU (yyt->Strip.List); break;
  10985. case klist:
  10986. yyTraverseTreeBU (yyt->list.Manifest_constant);
  10987. yyTraverseTreeBU (yyt->list.List); break;
  10988. case kInt:
  10989. yyTraverseTreeBU (yyt->Int.Sign); break;
  10990. case kReal:
  10991. yyTraverseTreeBU (yyt->Real.Sign); break;
  10992.  default: ;
  10993.  }
  10994.  yyProc (yyt);
  10995. }
  10996.  
  10997. void TraverseTreeBU
  10998. # if defined __STDC__ | defined __cplusplus
  10999.  (tTree yyt, Tree_tProcTree yyyProc)
  11000. # else
  11001.  (yyt, yyyProc) tTree yyt; Tree_tProcTree yyyProc;
  11002. # endif
  11003. {
  11004.  yyMark (yyt);
  11005.  yyProc = yyyProc;
  11006.  yyTraverseTreeBU (yyt);
  11007. }
  11008.  
  11009. tTree ReverseTree
  11010. # if defined __STDC__ | defined __cplusplus
  11011.  (tTree yyOld)
  11012. # else
  11013.  (yyOld) tTree yyOld;
  11014. # endif
  11015. {
  11016.  register tTree yyNew, yyNext, yyTail;
  11017.  yyNew = yyOld;
  11018.  yyTail = yyOld;
  11019.  for (;;) {
  11020.   switch (yyOld->Kind) {
  11021. case kClasses1: yyNext = yyOld->Classes1.Classes; yyOld->Classes1.Classes = yyNew; break;
  11022. case kIndex_list1: yyNext = yyOld->Index_list1.Index_list; yyOld->Index_list1.Index_list = yyNew; break;
  11023. case kFeatures1: yyNext = yyOld->Features1.Features; yyOld->Features1.Features = yyNew; break;
  11024. case kFeature_decls1: yyNext = yyOld->Feature_decls1.Feature_decls; yyOld->Feature_decls1.Feature_decls = yyNew; break;
  11025. case kParent_list1: yyNext = yyOld->Parent_list1.Parent_list; yyOld->Parent_list1.Parent_list = yyNew; break;
  11026. case kRename_list1: yyNext = yyOld->Rename_list1.Rename_list; yyOld->Rename_list1.Rename_list = yyNew; break;
  11027. case kCreators1: yyNext = yyOld->Creators1.Creators; yyOld->Creators1.Creators = yyNew; break;
  11028. case kNew_feature_list1: yyNext = yyOld->New_feature_list1.New_feature_list; yyOld->New_feature_list1.New_feature_list = yyNew; break;
  11029. case kNew_export_list1: yyNext = yyOld->New_export_list1.New_export_list; yyOld->New_export_list1.New_export_list = yyNew; break;
  11030. case kNew_export_item: yyNext = yyOld->New_export_item.Feature_set; yyOld->New_export_item.Feature_set = yyNew; break;
  11031. case kFeature_list1: yyNext = yyOld->Feature_list1.Feature_list; yyOld->Feature_list1.Feature_list = yyNew; break;
  11032. case kFormal_args1: yyNext = yyOld->Formal_args1.Formal_args; yyOld->Formal_args1.Formal_args = yyNew; break;
  11033. case kFormal_generics1: yyNext = yyOld->Formal_generics1.Formal_generics; yyOld->Formal_generics1.Formal_generics = yyNew; break;
  11034. case kCompound1: yyNext = yyOld->Compound1.Compound; yyOld->Compound1.Compound = yyNew; break;
  11035. case kThen_part_list1: yyNext = yyOld->Then_part_list1.Then_part_list; yyOld->Then_part_list1.Then_part_list = yyNew; break;
  11036. case kWhen_part_list1: yyNext = yyOld->When_part_list1.When_part_list; yyOld->When_part_list1.When_part_list = yyNew; break;
  11037. case kChoices1: yyNext = yyOld->Choices1.Choices; yyOld->Choices1.Choices = yyNew; break;
  11038. case kType_list1: yyNext = yyOld->Type_list1.Type_list; yyOld->Type_list1.Type_list = yyNew; break;
  11039. case kCall_chain1: yyNext = yyOld->Call_chain1.Call_chain; yyOld->Call_chain1.Call_chain = yyNew; break;
  11040. case kActual_list1: yyNext = yyOld->Actual_list1.Actual_list; yyOld->Actual_list1.Actual_list = yyNew; break;
  11041. case kManifest_array1: yyNext = yyOld->Manifest_array1.Manifest_array; yyOld->Manifest_array1.Manifest_array = yyNew; break;
  11042. case klist: yyNext = yyOld->list.List; yyOld->list.List = yyNew; break;
  11043.   default: goto yyExit;
  11044.   }
  11045.   yyNew = yyOld;
  11046.   yyOld = yyNext;
  11047.  }
  11048. yyExit:
  11049.  switch (yyTail->Kind) {
  11050. case kClasses1: yyTail->Classes1.Classes = yyOld; break;
  11051. case kIndex_list1: yyTail->Index_list1.Index_list = yyOld; break;
  11052. case kFeatures1: yyTail->Features1.Features = yyOld; break;
  11053. case kFeature_decls1: yyTail->Feature_decls1.Feature_decls = yyOld; break;
  11054. case kParent_list1: yyTail->Parent_list1.Parent_list = yyOld; break;
  11055. case kRename_list1: yyTail->Rename_list1.Rename_list = yyOld; break;
  11056. case kCreators1: yyTail->Creators1.Creators = yyOld; break;
  11057. case kNew_feature_list1: yyTail->New_feature_list1.New_feature_list = yyOld; break;
  11058. case kNew_export_list1: yyTail->New_export_list1.New_export_list = yyOld; break;
  11059. case kNew_export_item: yyTail->New_export_item.Feature_set = yyOld; break;
  11060. case kFeature_list1: yyTail->Feature_list1.Feature_list = yyOld; break;
  11061. case kFormal_args1: yyTail->Formal_args1.Formal_args = yyOld; break;
  11062. case kFormal_generics1: yyTail->Formal_generics1.Formal_generics = yyOld; break;
  11063. case kCompound1: yyTail->Compound1.Compound = yyOld; break;
  11064. case kThen_part_list1: yyTail->Then_part_list1.Then_part_list = yyOld; break;
  11065. case kWhen_part_list1: yyTail->When_part_list1.When_part_list = yyOld; break;
  11066. case kChoices1: yyTail->Choices1.Choices = yyOld; break;
  11067. case kType_list1: yyTail->Type_list1.Type_list = yyOld; break;
  11068. case kCall_chain1: yyTail->Call_chain1.Call_chain = yyOld; break;
  11069. case kActual_list1: yyTail->Actual_list1.Actual_list = yyOld; break;
  11070. case kManifest_array1: yyTail->Manifest_array1.Manifest_array = yyOld; break;
  11071. case klist: yyTail->list.List = yyOld; break;
  11072.  default: ;
  11073.  }
  11074.  return yyNew;
  11075. }
  11076.  
  11077. # define yyInitOldToNewStoreSize 32
  11078.  
  11079. typedef struct { tTree yyOld, yyNew; } yytOldToNew;
  11080. static unsigned long yyOldToNewStoreSize = yyInitOldToNewStoreSize;
  11081. static yytOldToNew yyOldToNewStore [yyInitOldToNewStoreSize];
  11082. static yytOldToNew * yyOldToNewStorePtr = yyOldToNewStore;
  11083. static int yyOldToNewCount;
  11084.  
  11085. static void yyStoreOldToNew
  11086. # if defined __STDC__ | defined __cplusplus
  11087.  (tTree yyOld, tTree yyNew)
  11088. # else
  11089.  (yyOld, yyNew) tTree yyOld, yyNew;
  11090. # endif
  11091. {
  11092.  if (++ yyOldToNewCount == yyOldToNewStoreSize)
  11093.   ExtendArray ((char * *) & yyOldToNewStorePtr, & yyOldToNewStoreSize, sizeof (yytOldToNew));
  11094.  yyOldToNewStorePtr [yyOldToNewCount].yyOld = yyOld;
  11095.  yyOldToNewStorePtr [yyOldToNewCount].yyNew = yyNew;
  11096. }
  11097.  
  11098. static tTree yyMapOldToNew
  11099. # if defined __STDC__ | defined __cplusplus
  11100.  (tTree yyOld)
  11101. # else
  11102.  (yyOld) tTree yyOld;
  11103. # endif
  11104. {
  11105.  register int yyi;
  11106.  for (yyi = 1; yyi <= yyOldToNewCount; yyi ++)
  11107.   if (yyOldToNewStorePtr [yyi].yyOld == yyOld) return yyOldToNewStorePtr [yyi].yyNew;
  11108. }
  11109.  
  11110. static tTree yyCopyTree
  11111. # if defined __STDC__ | defined __cplusplus
  11112.  (tTree yyt, yyPtrtTree yyNew)
  11113. # else
  11114.  (yyt, yyNew) tTree yyt; yyPtrtTree yyNew;
  11115. # endif
  11116. {
  11117.  for (;;) {
  11118.   if (yyt == NoTree) { * yyNew = NoTree; return; }
  11119.   if (yyt->yyHead.yyMark == 0) { * yyNew = yyMapOldToNew (yyt); return; }
  11120.   yyALLOC (* yyNew, Tree_NodeSize [yyt->Kind])
  11121.   if (yyt->yyHead.yyMark > 1) { yyStoreOldToNew (yyt, * yyNew); }
  11122.   yyt->yyHead.yyMark = 0;
  11123.  
  11124.   switch (yyt->Kind) {
  11125. case kEiffel: (* yyNew)->Eiffel = yyt->Eiffel;
  11126. yyt = yyt->Eiffel.Classes;
  11127. yyNew = & (* yyNew)->Eiffel.Classes; break;
  11128. case kClasses: (* yyNew)->Classes = yyt->Classes;
  11129. return;
  11130. case kClasses0: (* yyNew)->Classes0 = yyt->Classes0;
  11131. return;
  11132. case kClasses1: (* yyNew)->Classes1 = yyt->Classes1;
  11133. copytTree ((* yyNew)->Classes1.Class_declaration, yyt->Classes1.Class_declaration)
  11134. yyt = yyt->Classes1.Classes;
  11135. yyNew = & (* yyNew)->Classes1.Classes; break;
  11136. case kClass_declaration: (* yyNew)->Class_declaration = yyt->Class_declaration;
  11137. copytTree ((* yyNew)->Class_declaration.Indexing, yyt->Class_declaration.Indexing)
  11138. copytTree ((* yyNew)->Class_declaration.Class_header, yyt->Class_declaration.Class_header)
  11139. copytTree ((* yyNew)->Class_declaration.Formal_generics, yyt->Class_declaration.Formal_generics)
  11140. copytTree ((* yyNew)->Class_declaration.Obsolete, yyt->Class_declaration.Obsolete)
  11141. copytTree ((* yyNew)->Class_declaration.Inheritance, yyt->Class_declaration.Inheritance)
  11142. copytTree ((* yyNew)->Class_declaration.Creators, yyt->Class_declaration.Creators)
  11143. copytTree ((* yyNew)->Class_declaration.Features, yyt->Class_declaration.Features)
  11144. copytStringRef ((* yyNew)->Class_declaration.comment, yyt->Class_declaration.comment)
  11145. yyt = yyt->Class_declaration.Invariant;
  11146. yyNew = & (* yyNew)->Class_declaration.Invariant; break;
  11147. case kIndex_list: (* yyNew)->Index_list = yyt->Index_list;
  11148. return;
  11149. case kIndex_list0: (* yyNew)->Index_list0 = yyt->Index_list0;
  11150. return;
  11151. case kIndex_list1: (* yyNew)->Index_list1 = yyt->Index_list1;
  11152. copytTree ((* yyNew)->Index_list1.Index_clause, yyt->Index_list1.Index_clause)
  11153. yyt = yyt->Index_list1.Index_list;
  11154. yyNew = & (* yyNew)->Index_list1.Index_list; break;
  11155. case kIndex_clause: (* yyNew)->Index_clause = yyt->Index_clause;
  11156. copytTree ((* yyNew)->Index_clause.Index, yyt->Index_clause.Index)
  11157. yyt = yyt->Index_clause.Index_terms;
  11158. yyNew = & (* yyNew)->Index_clause.Index_terms; break;
  11159. case kClass_header: (* yyNew)->Class_header = yyt->Class_header;
  11160. return;
  11161. case kClass_header0: (* yyNew)->Class_header0 = yyt->Class_header0;
  11162. return;
  11163. case kClass: (* yyNew)->Class = yyt->Class;
  11164. yyt = yyt->Class.Name;
  11165. yyNew = & (* yyNew)->Class.Name; break;
  11166. case kExpanded_class: (* yyNew)->Expanded_class = yyt->Expanded_class;
  11167. yyt = yyt->Expanded_class.Name;
  11168. yyNew = & (* yyNew)->Expanded_class.Name; break;
  11169. case kDeferred_class: (* yyNew)->Deferred_class = yyt->Deferred_class;
  11170. yyt = yyt->Deferred_class.Name;
  11171. yyNew = & (* yyNew)->Deferred_class.Name; break;
  11172. case kFeatures: (* yyNew)->Features = yyt->Features;
  11173. return;
  11174. case kFeatures0: (* yyNew)->Features0 = yyt->Features0;
  11175. return;
  11176. case kFeatures1: (* yyNew)->Features1 = yyt->Features1;
  11177. copytTree ((* yyNew)->Features1.Feature_clause, yyt->Features1.Feature_clause)
  11178. yyt = yyt->Features1.Features;
  11179. yyNew = & (* yyNew)->Features1.Features; break;
  11180. case kFeature_clause: (* yyNew)->Feature_clause = yyt->Feature_clause;
  11181. copytTree ((* yyNew)->Feature_clause.Clients, yyt->Feature_clause.Clients)
  11182. copytStringRef ((* yyNew)->Feature_clause.comment, yyt->Feature_clause.comment)
  11183. yyt = yyt->Feature_clause.Feature_decls;
  11184. yyNew = & (* yyNew)->Feature_clause.Feature_decls; break;
  11185. case kClients: (* yyNew)->Clients = yyt->Clients;
  11186. return;
  11187. case kClients0: (* yyNew)->Clients0 = yyt->Clients0;
  11188. return;
  11189. case kClients1: (* yyNew)->Clients1 = yyt->Clients1;
  11190. yyt = yyt->Clients1.List;
  11191. yyNew = & (* yyNew)->Clients1.List; break;
  11192. case kFeature_decls: (* yyNew)->Feature_decls = yyt->Feature_decls;
  11193. return;
  11194. case kFeature_decls0: (* yyNew)->Feature_decls0 = yyt->Feature_decls0;
  11195. return;
  11196. case kFeature_decls1: (* yyNew)->Feature_decls1 = yyt->Feature_decls1;
  11197. copytTree ((* yyNew)->Feature_decls1.Feature_decl, yyt->Feature_decls1.Feature_decl)
  11198. yyt = yyt->Feature_decls1.Feature_decls;
  11199. yyNew = & (* yyNew)->Feature_decls1.Feature_decls; break;
  11200. case kFeature_decl: (* yyNew)->Feature_decl = yyt->Feature_decl;
  11201. copytTree ((* yyNew)->Feature_decl.New_feature_list, yyt->Feature_decl.New_feature_list)
  11202. yyt = yyt->Feature_decl.Declaration_body;
  11203. yyNew = & (* yyNew)->Feature_decl.Declaration_body; break;
  11204. case kDeclaration_body: (* yyNew)->Declaration_body = yyt->Declaration_body;
  11205. copytTree ((* yyNew)->Declaration_body.Formal_args, yyt->Declaration_body.Formal_args)
  11206. copytTree ((* yyNew)->Declaration_body.Type_mark, yyt->Declaration_body.Type_mark)
  11207. yyt = yyt->Declaration_body.Const_or_routine;
  11208. yyNew = & (* yyNew)->Declaration_body.Const_or_routine; break;
  11209. case kConst_or_routine: (* yyNew)->Const_or_routine = yyt->Const_or_routine;
  11210. return;
  11211. case kConst_or_routine0: (* yyNew)->Const_or_routine0 = yyt->Const_or_routine0;
  11212. return;
  11213. case kM_const: (* yyNew)->M_const = yyt->M_const;
  11214. yyt = yyt->M_const.Manifest_constant;
  11215. yyNew = & (* yyNew)->M_const.Manifest_constant; break;
  11216. case kUnique: (* yyNew)->Unique = yyt->Unique;
  11217. copytPosition ((* yyNew)->Unique.pos, yyt->Unique.pos)
  11218. return;
  11219. case kRoutine: (* yyNew)->Routine = yyt->Routine;
  11220. copytTree ((* yyNew)->Routine.Obsolete, yyt->Routine.Obsolete)
  11221. copytStringRef ((* yyNew)->Routine.comment, yyt->Routine.comment)
  11222. copytTree ((* yyNew)->Routine.Precondition, yyt->Routine.Precondition)
  11223. copytTree ((* yyNew)->Routine.Local_decls, yyt->Routine.Local_decls)
  11224. copytTree ((* yyNew)->Routine.Routine_body, yyt->Routine.Routine_body)
  11225. copytTree ((* yyNew)->Routine.Postcondition, yyt->Routine.Postcondition)
  11226. copytStringRef ((* yyNew)->Routine.end_comment, yyt->Routine.end_comment)
  11227. yyt = yyt->Routine.Rescue;
  11228. yyNew = & (* yyNew)->Routine.Rescue; break;
  11229. case kParent_list: (* yyNew)->Parent_list = yyt->Parent_list;
  11230. return;
  11231. case kParent_list0: (* yyNew)->Parent_list0 = yyt->Parent_list0;
  11232. return;
  11233. case kParent_list1: (* yyNew)->Parent_list1 = yyt->Parent_list1;
  11234. copytTree ((* yyNew)->Parent_list1.Parent, yyt->Parent_list1.Parent)
  11235. yyt = yyt->Parent_list1.Parent_list;
  11236. yyNew = & (* yyNew)->Parent_list1.Parent_list; break;
  11237. case kParent: (* yyNew)->Parent = yyt->Parent;
  11238. copytTree ((* yyNew)->Parent.Class_type, yyt->Parent.Class_type)
  11239. yyt = yyt->Parent.Feature_adaptation;
  11240. yyNew = & (* yyNew)->Parent.Feature_adaptation; break;
  11241. case kFeature_adaptation: (* yyNew)->Feature_adaptation = yyt->Feature_adaptation;
  11242. return;
  11243. case kFeature_adaptation0: (* yyNew)->Feature_adaptation0 = yyt->Feature_adaptation0;
  11244. return;
  11245. case kFeature_adaptation1: (* yyNew)->Feature_adaptation1 = yyt->Feature_adaptation1;
  11246. copytTree ((* yyNew)->Feature_adaptation1.Rename, yyt->Feature_adaptation1.Rename)
  11247. copytTree ((* yyNew)->Feature_adaptation1.New_export, yyt->Feature_adaptation1.New_export)
  11248. copytTree ((* yyNew)->Feature_adaptation1.Undefine, yyt->Feature_adaptation1.Undefine)
  11249. copytTree ((* yyNew)->Feature_adaptation1.Redefine, yyt->Feature_adaptation1.Redefine)
  11250. yyt = yyt->Feature_adaptation1.Select;
  11251. yyNew = & (* yyNew)->Feature_adaptation1.Select; break;
  11252. case kRename_list: (* yyNew)->Rename_list = yyt->Rename_list;
  11253. return;
  11254. case kRename_list0: (* yyNew)->Rename_list0 = yyt->Rename_list0;
  11255. return;
  11256. case kRename_list1: (* yyNew)->Rename_list1 = yyt->Rename_list1;
  11257. copytTree ((* yyNew)->Rename_list1.Rename_pair, yyt->Rename_list1.Rename_pair)
  11258. yyt = yyt->Rename_list1.Rename_list;
  11259. yyNew = & (* yyNew)->Rename_list1.Rename_list; break;
  11260. case kRename_pair: (* yyNew)->Rename_pair = yyt->Rename_pair;
  11261. copytTree ((* yyNew)->Rename_pair.Name1, yyt->Rename_pair.Name1)
  11262. yyt = yyt->Rename_pair.Name2;
  11263. yyNew = & (* yyNew)->Rename_pair.Name2; break;
  11264. case kCreators: (* yyNew)->Creators = yyt->Creators;
  11265. return;
  11266. case kCreators0: (* yyNew)->Creators0 = yyt->Creators0;
  11267. return;
  11268. case kCreators1: (* yyNew)->Creators1 = yyt->Creators1;
  11269. copytTree ((* yyNew)->Creators1.Creation_clause, yyt->Creators1.Creation_clause)
  11270. yyt = yyt->Creators1.Creators;
  11271. yyNew = & (* yyNew)->Creators1.Creators; break;
  11272. case kCreation_clause: (* yyNew)->Creation_clause = yyt->Creation_clause;
  11273. copytTree ((* yyNew)->Creation_clause.Clients, yyt->Creation_clause.Clients)
  11274. copytStringRef ((* yyNew)->Creation_clause.comment, yyt->Creation_clause.comment)
  11275. yyt = yyt->Creation_clause.Feature_list;
  11276. yyNew = & (* yyNew)->Creation_clause.Feature_list; break;
  11277. case kNew_feature_list: (* yyNew)->New_feature_list = yyt->New_feature_list;
  11278. return;
  11279. case kNew_feature_list0: (* yyNew)->New_feature_list0 = yyt->New_feature_list0;
  11280. return;
  11281. case kNew_feature_list1: (* yyNew)->New_feature_list1 = yyt->New_feature_list1;
  11282. copytTree ((* yyNew)->New_feature_list1.Feature_name, yyt->New_feature_list1.Feature_name)
  11283. yyt = yyt->New_feature_list1.New_feature_list;
  11284. yyNew = & (* yyNew)->New_feature_list1.New_feature_list; break;
  11285. case kFeature_name: (* yyNew)->Feature_name = yyt->Feature_name;
  11286. return;
  11287. case kFrozen: (* yyNew)->Frozen = yyt->Frozen;
  11288. yyt = yyt->Frozen.Feature_name;
  11289. yyNew = & (* yyNew)->Frozen.Feature_name; break;
  11290. case kIdent_name: (* yyNew)->Ident_name = yyt->Ident_name;
  11291. yyt = yyt->Ident_name.Id;
  11292. yyNew = & (* yyNew)->Ident_name.Id; break;
  11293. case kOp: (* yyNew)->Op = yyt->Op;
  11294. return;
  11295. case kPrefix: (* yyNew)->Prefix = yyt->Prefix;
  11296. yyt = yyt->Prefix.Op_name;
  11297. yyNew = & (* yyNew)->Prefix.Op_name; break;
  11298. case kInfix: (* yyNew)->Infix = yyt->Infix;
  11299. yyt = yyt->Infix.Op_name;
  11300. yyNew = & (* yyNew)->Infix.Op_name; break;
  11301. case kOp_name: (* yyNew)->Op_name = yyt->Op_name;
  11302. copytPosition ((* yyNew)->Op_name.pos, yyt->Op_name.pos)
  11303. return;
  11304. case kFree_op: (* yyNew)->Free_op = yyt->Free_op;
  11305. copytPosition ((* yyNew)->Free_op.pos, yyt->Free_op.pos)
  11306. copytIdent ((* yyNew)->Free_op.ident, yyt->Free_op.ident)
  11307. return;
  11308. case kOper: (* yyNew)->Oper = yyt->Oper;
  11309. copytPosition ((* yyNew)->Oper.pos, yyt->Oper.pos)
  11310. copyint ((* yyNew)->Oper.op, yyt->Oper.op)
  11311. return;
  11312. case kNew_export_list: (* yyNew)->New_export_list = yyt->New_export_list;
  11313. return;
  11314. case kNew_export_list0: (* yyNew)->New_export_list0 = yyt->New_export_list0;
  11315. return;
  11316. case kNew_export_list1: (* yyNew)->New_export_list1 = yyt->New_export_list1;
  11317. copytTree ((* yyNew)->New_export_list1.New_export_item, yyt->New_export_list1.New_export_item)
  11318. yyt = yyt->New_export_list1.New_export_list;
  11319. yyNew = & (* yyNew)->New_export_list1.New_export_list; break;
  11320. case kNew_export_item: (* yyNew)->New_export_item = yyt->New_export_item;
  11321. copytTree ((* yyNew)->New_export_item.Clients, yyt->New_export_item.Clients)
  11322. yyt = yyt->New_export_item.Feature_set;
  11323. yyNew = & (* yyNew)->New_export_item.Feature_set; break;
  11324. case kFeature_list: (* yyNew)->Feature_list = yyt->Feature_list;
  11325. return;
  11326. case kAll: (* yyNew)->All = yyt->All;
  11327. return;
  11328. case kFeature_list0: (* yyNew)->Feature_list0 = yyt->Feature_list0;
  11329. return;
  11330. case kFeature_list1: (* yyNew)->Feature_list1 = yyt->Feature_list1;
  11331. copytTree ((* yyNew)->Feature_list1.Feature_name, yyt->Feature_list1.Feature_name)
  11332. yyt = yyt->Feature_list1.Feature_list;
  11333. yyNew = & (* yyNew)->Feature_list1.Feature_list; break;
  11334. case kFormal_args: (* yyNew)->Formal_args = yyt->Formal_args;
  11335. return;
  11336. case kFormal_args0: (* yyNew)->Formal_args0 = yyt->Formal_args0;
  11337. return;
  11338. case kFormal_args1: (* yyNew)->Formal_args1 = yyt->Formal_args1;
  11339. copytTree ((* yyNew)->Formal_args1.Entity_decl_group, yyt->Formal_args1.Entity_decl_group)
  11340. yyt = yyt->Formal_args1.Formal_args;
  11341. yyNew = & (* yyNew)->Formal_args1.Formal_args; break;
  11342. case kRoutine_body: (* yyNew)->Routine_body = yyt->Routine_body;
  11343. return;
  11344. case kRoutine_body0: (* yyNew)->Routine_body0 = yyt->Routine_body0;
  11345. return;
  11346. case kEffective: (* yyNew)->Effective = yyt->Effective;
  11347. return;
  11348. case kInternal: (* yyNew)->Internal = yyt->Internal;
  11349. return;
  11350. case kDo_body: (* yyNew)->Do_body = yyt->Do_body;
  11351. yyt = yyt->Do_body.Compound;
  11352. yyNew = & (* yyNew)->Do_body.Compound; break;
  11353. case kOnce_body: (* yyNew)->Once_body = yyt->Once_body;
  11354. yyt = yyt->Once_body.Compound;
  11355. yyNew = & (* yyNew)->Once_body.Compound; break;
  11356. case kExternal: (* yyNew)->External = yyt->External;
  11357. copytTree ((* yyNew)->External.Lang1, yyt->External.Lang1)
  11358. yyt = yyt->External.Lang2;
  11359. yyNew = & (* yyNew)->External.Lang2; break;
  11360. case kDeferred: (* yyNew)->Deferred = yyt->Deferred;
  11361. copytPosition ((* yyNew)->Deferred.pos, yyt->Deferred.pos)
  11362. return;
  11363. case kEntity_decl_group: (* yyNew)->Entity_decl_group = yyt->Entity_decl_group;
  11364. copytTree ((* yyNew)->Entity_decl_group.Id_list, yyt->Entity_decl_group.Id_list)
  11365. yyt = yyt->Entity_decl_group.Type_mark;
  11366. yyNew = & (* yyNew)->Entity_decl_group.Type_mark; break;
  11367. case kFormal_generics: (* yyNew)->Formal_generics = yyt->Formal_generics;
  11368. return;
  11369. case kFormal_generics0: (* yyNew)->Formal_generics0 = yyt->Formal_generics0;
  11370. return;
  11371. case kFormal_generics1: (* yyNew)->Formal_generics1 = yyt->Formal_generics1;
  11372. copytTree ((* yyNew)->Formal_generics1.Formal_generic, yyt->Formal_generics1.Formal_generic)
  11373. yyt = yyt->Formal_generics1.Formal_generics;
  11374. yyNew = & (* yyNew)->Formal_generics1.Formal_generics; break;
  11375. case kFormal_generic: (* yyNew)->Formal_generic = yyt->Formal_generic;
  11376. copytTree ((* yyNew)->Formal_generic.Id, yyt->Formal_generic.Id)
  11377. yyt = yyt->Formal_generic.Constraint;
  11378. yyNew = & (* yyNew)->Formal_generic.Constraint; break;
  11379. case kConstraint: (* yyNew)->Constraint = yyt->Constraint;
  11380. return;
  11381. case kConstraint0: (* yyNew)->Constraint0 = yyt->Constraint0;
  11382. return;
  11383. case kConstraint1: (* yyNew)->Constraint1 = yyt->Constraint1;
  11384. yyt = yyt->Constraint1.Class_type;
  11385. yyNew = & (* yyNew)->Constraint1.Class_type; break;
  11386. case kCompound: (* yyNew)->Compound = yyt->Compound;
  11387. return;
  11388. case kCompound0: (* yyNew)->Compound0 = yyt->Compound0;
  11389. return;
  11390. case kCompound1: (* yyNew)->Compound1 = yyt->Compound1;
  11391. copytTree ((* yyNew)->Compound1.Instruction, yyt->Compound1.Instruction)
  11392. yyt = yyt->Compound1.Compound;
  11393. yyNew = & (* yyNew)->Compound1.Compound; break;
  11394. case kThen_part_list: (* yyNew)->Then_part_list = yyt->Then_part_list;
  11395. return;
  11396. case kThen_part_list0: (* yyNew)->Then_part_list0 = yyt->Then_part_list0;
  11397. return;
  11398. case kThen_part_list1: (* yyNew)->Then_part_list1 = yyt->Then_part_list1;
  11399. copytTree ((* yyNew)->Then_part_list1.Then_part, yyt->Then_part_list1.Then_part)
  11400. yyt = yyt->Then_part_list1.Then_part_list;
  11401. yyNew = & (* yyNew)->Then_part_list1.Then_part_list; break;
  11402. case kThen_part: (* yyNew)->Then_part = yyt->Then_part;
  11403. copytTree ((* yyNew)->Then_part.Guard, yyt->Then_part.Guard)
  11404. yyt = yyt->Then_part.Compound;
  11405. yyNew = & (* yyNew)->Then_part.Compound; break;
  11406. case kWhen_part_list: (* yyNew)->When_part_list = yyt->When_part_list;
  11407. return;
  11408. case kWhen_part_list0: (* yyNew)->When_part_list0 = yyt->When_part_list0;
  11409. return;
  11410. case kWhen_part_list1: (* yyNew)->When_part_list1 = yyt->When_part_list1;
  11411. copytTree ((* yyNew)->When_part_list1.When_part, yyt->When_part_list1.When_part)
  11412. yyt = yyt->When_part_list1.When_part_list;
  11413. yyNew = & (* yyNew)->When_part_list1.When_part_list; break;
  11414. case kWhen_part: (* yyNew)->When_part = yyt->When_part;
  11415. copytTree ((* yyNew)->When_part.Choices, yyt->When_part.Choices)
  11416. yyt = yyt->When_part.Compound;
  11417. yyNew = & (* yyNew)->When_part.Compound; break;
  11418. case kChoices: (* yyNew)->Choices = yyt->Choices;
  11419. return;
  11420. case kChoices0: (* yyNew)->Choices0 = yyt->Choices0;
  11421. return;
  11422. case kChoices1: (* yyNew)->Choices1 = yyt->Choices1;
  11423. copytTree ((* yyNew)->Choices1.Choice, yyt->Choices1.Choice)
  11424. yyt = yyt->Choices1.Choices;
  11425. yyNew = & (* yyNew)->Choices1.Choices; break;
  11426. case kChoice: (* yyNew)->Choice = yyt->Choice;
  11427. return;
  11428. case kInterval: (* yyNew)->Interval = yyt->Interval;
  11429. copytTree ((* yyNew)->Interval.From, yyt->Interval.From)
  11430. yyt = yyt->Interval.To;
  11431. yyNew = & (* yyNew)->Interval.To; break;
  11432. case kVal: (* yyNew)->Val = yyt->Val;
  11433. yyt = yyt->Val.Manifest_constant;
  11434. yyNew = & (* yyNew)->Val.Manifest_constant; break;
  11435. case kInstruction: (* yyNew)->Instruction = yyt->Instruction;
  11436. return;
  11437. case kInstruction0: (* yyNew)->Instruction0 = yyt->Instruction0;
  11438. return;
  11439. case kCreation: (* yyNew)->Creation = yyt->Creation;
  11440. copytTree ((* yyNew)->Creation.Type, yyt->Creation.Type)
  11441. copytTree ((* yyNew)->Creation.Entity, yyt->Creation.Entity)
  11442. yyt = yyt->Creation.Unqual_call;
  11443. yyNew = & (* yyNew)->Creation.Unqual_call; break;
  11444. case kCall_instruct: (* yyNew)->Call_instruct = yyt->Call_instruct;
  11445. yyt = yyt->Call_instruct.Call;
  11446. yyNew = & (* yyNew)->Call_instruct.Call; break;
  11447. case kAssign: (* yyNew)->Assign = yyt->Assign;
  11448. copytTree ((* yyNew)->Assign.Addr, yyt->Assign.Addr)
  11449. yyt = yyt->Assign.Expression;
  11450. yyNew = & (* yyNew)->Assign.Expression; break;
  11451. case kRev_assign: (* yyNew)->Rev_assign = yyt->Rev_assign;
  11452. copytTree ((* yyNew)->Rev_assign.Addr, yyt->Rev_assign.Addr)
  11453. yyt = yyt->Rev_assign.Expression;
  11454. yyNew = & (* yyNew)->Rev_assign.Expression; break;
  11455. case kConditional: (* yyNew)->Conditional = yyt->Conditional;
  11456. copytTree ((* yyNew)->Conditional.Then_part, yyt->Conditional.Then_part)
  11457. yyt = yyt->Conditional.Else_part;
  11458. yyNew = & (* yyNew)->Conditional.Else_part; break;
  11459. case kMulti_branch: (* yyNew)->Multi_branch = yyt->Multi_branch;
  11460. copytTree ((* yyNew)->Multi_branch.Guard, yyt->Multi_branch.Guard)
  11461. copytTree ((* yyNew)->Multi_branch.When_part_list, yyt->Multi_branch.When_part_list)
  11462. yyt = yyt->Multi_branch.Else_part;
  11463. yyNew = & (* yyNew)->Multi_branch.Else_part; break;
  11464. case kLoop: (* yyNew)->Loop = yyt->Loop;
  11465. copytTree ((* yyNew)->Loop.Initialization, yyt->Loop.Initialization)
  11466. copytTree ((* yyNew)->Loop.Invariant, yyt->Loop.Invariant)
  11467. copytTree ((* yyNew)->Loop.Variant, yyt->Loop.Variant)
  11468. yyt = yyt->Loop.Loop_body;
  11469. yyNew = & (* yyNew)->Loop.Loop_body; break;
  11470. case kCheck: (* yyNew)->Check = yyt->Check;
  11471. yyt = yyt->Check.Assertion;
  11472. yyNew = & (* yyNew)->Check.Assertion; break;
  11473. case kDebug: (* yyNew)->Debug = yyt->Debug;
  11474. copytTree ((* yyNew)->Debug.Debug_keys, yyt->Debug.Debug_keys)
  11475. yyt = yyt->Debug.Compound;
  11476. yyNew = & (* yyNew)->Debug.Compound; break;
  11477. case kRetry: (* yyNew)->Retry = yyt->Retry;
  11478. copytPosition ((* yyNew)->Retry.pos, yyt->Retry.pos)
  11479. return;
  11480. case kLoop_body: (* yyNew)->Loop_body = yyt->Loop_body;
  11481. return;
  11482. case kLoop_body0: (* yyNew)->Loop_body0 = yyt->Loop_body0;
  11483. return;
  11484. case kLoop_body1: (* yyNew)->Loop_body1 = yyt->Loop_body1;
  11485. copytTree ((* yyNew)->Loop_body1.Exit, yyt->Loop_body1.Exit)
  11486. yyt = yyt->Loop_body1.Compound;
  11487. yyNew = & (* yyNew)->Loop_body1.Compound; break;
  11488. case kType: (* yyNew)->Type = yyt->Type;
  11489. return;
  11490. case kType0: (* yyNew)->Type0 = yyt->Type0;
  11491. return;
  11492. case kClass_type: (* yyNew)->Class_type = yyt->Class_type;
  11493. copytTree ((* yyNew)->Class_type.Id, yyt->Class_type.Id)
  11494. yyt = yyt->Class_type.Actual_generics;
  11495. yyNew = & (* yyNew)->Class_type.Actual_generics; break;
  11496. case kClass_type_expanded: (* yyNew)->Class_type_expanded = yyt->Class_type_expanded;
  11497. copytTree ((* yyNew)->Class_type_expanded.Id, yyt->Class_type_expanded.Id)
  11498. yyt = yyt->Class_type_expanded.Actual_generics;
  11499. yyNew = & (* yyNew)->Class_type_expanded.Actual_generics; break;
  11500. case kBit_type: (* yyNew)->Bit_type = yyt->Bit_type;
  11501. yyt = yyt->Bit_type.Manifest_constant;
  11502. yyNew = & (* yyNew)->Bit_type.Manifest_constant; break;
  11503. case kSimple_type: (* yyNew)->Simple_type = yyt->Simple_type;
  11504. yyt = yyt->Simple_type.Manifest_constant;
  11505. yyNew = & (* yyNew)->Simple_type.Manifest_constant; break;
  11506. case kAnchored: (* yyNew)->Anchored = yyt->Anchored;
  11507. yyt = yyt->Anchored.Entity;
  11508. yyNew = & (* yyNew)->Anchored.Entity; break;
  11509. case kActual_generics: (* yyNew)->Actual_generics = yyt->Actual_generics;
  11510. return;
  11511. case kActual_generics0: (* yyNew)->Actual_generics0 = yyt->Actual_generics0;
  11512. return;
  11513. case kActual_generics1: (* yyNew)->Actual_generics1 = yyt->Actual_generics1;
  11514. yyt = yyt->Actual_generics1.Type_list;
  11515. yyNew = & (* yyNew)->Actual_generics1.Type_list; break;
  11516. case kCondition: (* yyNew)->Condition = yyt->Condition;
  11517. return;
  11518. case kCondition0: (* yyNew)->Condition0 = yyt->Condition0;
  11519. return;
  11520. case kCondition1: (* yyNew)->Condition1 = yyt->Condition1;
  11521. copyint ((* yyNew)->Condition1.extension, yyt->Condition1.extension)
  11522. yyt = yyt->Condition1.Assertion;
  11523. yyNew = & (* yyNew)->Condition1.Assertion; break;
  11524. case kAssertion: (* yyNew)->Assertion = yyt->Assertion;
  11525. return;
  11526. case kAssertion0: (* yyNew)->Assertion0 = yyt->Assertion0;
  11527. return;
  11528. case kAssertion1: (* yyNew)->Assertion1 = yyt->Assertion1;
  11529. copytTree ((* yyNew)->Assertion1.Assertion_clause, yyt->Assertion1.Assertion_clause)
  11530. yyt = yyt->Assertion1.Assertion;
  11531. yyNew = & (* yyNew)->Assertion1.Assertion; break;
  11532. case kAssertion_clause: (* yyNew)->Assertion_clause = yyt->Assertion_clause;
  11533. return;
  11534. case kAssertion_clause0: (* yyNew)->Assertion_clause0 = yyt->Assertion_clause0;
  11535. return;
  11536. case kAssertion_clause1: (* yyNew)->Assertion_clause1 = yyt->Assertion_clause1;
  11537. copytTree ((* yyNew)->Assertion_clause1.Tag, yyt->Assertion_clause1.Tag)
  11538. yyt = yyt->Assertion_clause1.Expression;
  11539. yyNew = & (* yyNew)->Assertion_clause1.Expression; break;
  11540. case kType_list: (* yyNew)->Type_list = yyt->Type_list;
  11541. return;
  11542. case kType_list0: (* yyNew)->Type_list0 = yyt->Type_list0;
  11543. return;
  11544. case kType_list1: (* yyNew)->Type_list1 = yyt->Type_list1;
  11545. copytTree ((* yyNew)->Type_list1.Type, yyt->Type_list1.Type)
  11546. yyt = yyt->Type_list1.Type_list;
  11547. yyNew = & (* yyNew)->Type_list1.Type_list; break;
  11548. case kCall_chain: (* yyNew)->Call_chain = yyt->Call_chain;
  11549. return;
  11550. case kCall_chain0: (* yyNew)->Call_chain0 = yyt->Call_chain0;
  11551. return;
  11552. case kCall_chain1: (* yyNew)->Call_chain1 = yyt->Call_chain1;
  11553. copytTree ((* yyNew)->Call_chain1.Unqual_call, yyt->Call_chain1.Unqual_call)
  11554. yyt = yyt->Call_chain1.Call_chain;
  11555. yyNew = & (* yyNew)->Call_chain1.Call_chain; break;
  11556. case kUnqual_call: (* yyNew)->Unqual_call = yyt->Unqual_call;
  11557. return;
  11558. case kUnqual_call0: (* yyNew)->Unqual_call0 = yyt->Unqual_call0;
  11559. return;
  11560. case kUnqual_call1: (* yyNew)->Unqual_call1 = yyt->Unqual_call1;
  11561. copytTree ((* yyNew)->Unqual_call1.Entity, yyt->Unqual_call1.Entity)
  11562. yyt = yyt->Unqual_call1.Actuals;
  11563. yyNew = & (* yyNew)->Unqual_call1.Actuals; break;
  11564. case kActuals: (* yyNew)->Actuals = yyt->Actuals;
  11565. return;
  11566. case kActuals0: (* yyNew)->Actuals0 = yyt->Actuals0;
  11567. return;
  11568. case kActuals1: (* yyNew)->Actuals1 = yyt->Actuals1;
  11569. yyt = yyt->Actuals1.Actual_list;
  11570. yyNew = & (* yyNew)->Actuals1.Actual_list; break;
  11571. case kActual_list: (* yyNew)->Actual_list = yyt->Actual_list;
  11572. return;
  11573. case kActual_list0: (* yyNew)->Actual_list0 = yyt->Actual_list0;
  11574. return;
  11575. case kActual_list1: (* yyNew)->Actual_list1 = yyt->Actual_list1;
  11576. copytTree ((* yyNew)->Actual_list1.Actual, yyt->Actual_list1.Actual)
  11577. yyt = yyt->Actual_list1.Actual_list;
  11578. yyNew = & (* yyNew)->Actual_list1.Actual_list; break;
  11579. case kActual: (* yyNew)->Actual = yyt->Actual;
  11580. return;
  11581. case kAddr: (* yyNew)->Addr = yyt->Addr;
  11582. yyt = yyt->Addr.Entity;
  11583. yyNew = & (* yyNew)->Addr.Entity; break;
  11584. case kExpression: (* yyNew)->Expression = yyt->Expression;
  11585. return;
  11586. case kExpression0: (* yyNew)->Expression0 = yyt->Expression0;
  11587. return;
  11588. case kComment: (* yyNew)->Comment = yyt->Comment;
  11589. copytStringRef ((* yyNew)->Comment.comment, yyt->Comment.comment)
  11590. return;
  11591. case kSimple_expr: (* yyNew)->Simple_expr = yyt->Simple_expr;
  11592. yyt = yyt->Simple_expr.Manifest_constant;
  11593. yyNew = & (* yyNew)->Simple_expr.Manifest_constant; break;
  11594. case kCall: (* yyNew)->Call = yyt->Call;
  11595. copytTree ((* yyNew)->Call.Qual, yyt->Call.Qual)
  11596. yyt = yyt->Call.Call_chain;
  11597. yyNew = & (* yyNew)->Call.Call_chain; break;
  11598. case kBin_expr: (* yyNew)->Bin_expr = yyt->Bin_expr;
  11599. copytTree ((* yyNew)->Bin_expr.Lop, yyt->Bin_expr.Lop)
  11600. copytTree ((* yyNew)->Bin_expr.Op, yyt->Bin_expr.Op)
  11601. yyt = yyt->Bin_expr.Rop;
  11602. yyNew = & (* yyNew)->Bin_expr.Rop; break;
  11603. case kUn_expr: (* yyNew)->Un_expr = yyt->Un_expr;
  11604. copytTree ((* yyNew)->Un_expr.Op, yyt->Un_expr.Op)
  11605. yyt = yyt->Un_expr.Expression;
  11606. yyNew = & (* yyNew)->Un_expr.Expression; break;
  11607. case kParenth: (* yyNew)->Parenth = yyt->Parenth;
  11608. yyt = yyt->Parenth.Expression;
  11609. yyNew = & (* yyNew)->Parenth.Expression; break;
  11610. case kManifest_array: (* yyNew)->Manifest_array = yyt->Manifest_array;
  11611. return;
  11612. case kManifest_array0: (* yyNew)->Manifest_array0 = yyt->Manifest_array0;
  11613. return;
  11614. case kManifest_array1: (* yyNew)->Manifest_array1 = yyt->Manifest_array1;
  11615. copytTree ((* yyNew)->Manifest_array1.Expression, yyt->Manifest_array1.Expression)
  11616. yyt = yyt->Manifest_array1.Manifest_array;
  11617. yyNew = & (* yyNew)->Manifest_array1.Manifest_array; break;
  11618. case kOld: (* yyNew)->Old = yyt->Old;
  11619. yyt = yyt->Old.Expression;
  11620. yyNew = & (* yyNew)->Old.Expression; break;
  11621. case kStrip: (* yyNew)->Strip = yyt->Strip;
  11622. yyt = yyt->Strip.List;
  11623. yyNew = & (* yyNew)->Strip.List; break;
  11624. case kList: (* yyNew)->List = yyt->List;
  11625. return;
  11626. case knolist: (* yyNew)->nolist = yyt->nolist;
  11627. return;
  11628. case klist: (* yyNew)->list = yyt->list;
  11629. copytTree ((* yyNew)->list.Manifest_constant, yyt->list.Manifest_constant)
  11630. yyt = yyt->list.List;
  11631. yyNew = & (* yyNew)->list.List; break;
  11632. case kManifest_constant: (* yyNew)->Manifest_constant = yyt->Manifest_constant;
  11633. return;
  11634. case kManifest_constant0: (* yyNew)->Manifest_constant0 = yyt->Manifest_constant0;
  11635. return;
  11636. case kCh: (* yyNew)->Ch = yyt->Ch;
  11637. copyint ((* yyNew)->Ch.ch, yyt->Ch.ch)
  11638. copytPosition ((* yyNew)->Ch.pos, yyt->Ch.pos)
  11639. return;
  11640. case kTrue: (* yyNew)->True = yyt->True;
  11641. copytPosition ((* yyNew)->True.pos, yyt->True.pos)
  11642. return;
  11643. case kFalse: (* yyNew)->False = yyt->False;
  11644. copytPosition ((* yyNew)->False.pos, yyt->False.pos)
  11645. return;
  11646. case kInt: (* yyNew)->Int = yyt->Int;
  11647. copylong ((* yyNew)->Int.value, yyt->Int.value)
  11648. copytPosition ((* yyNew)->Int.pos, yyt->Int.pos)
  11649. yyt = yyt->Int.Sign;
  11650. yyNew = & (* yyNew)->Int.Sign; break;
  11651. case kReal: (* yyNew)->Real = yyt->Real;
  11652. copydouble ((* yyNew)->Real.value, yyt->Real.value)
  11653. copytPosition ((* yyNew)->Real.pos, yyt->Real.pos)
  11654. yyt = yyt->Real.Sign;
  11655. yyNew = & (* yyNew)->Real.Sign; break;
  11656. case k_CHARACTER: (* yyNew)->_CHARACTER = yyt->_CHARACTER;
  11657. copytPosition ((* yyNew)->_CHARACTER.pos, yyt->_CHARACTER.pos)
  11658. return;
  11659. case k_INTEGER: (* yyNew)->_INTEGER = yyt->_INTEGER;
  11660. copytPosition ((* yyNew)->_INTEGER.pos, yyt->_INTEGER.pos)
  11661. return;
  11662. case k_REAL: (* yyNew)->_REAL = yyt->_REAL;
  11663. copytPosition ((* yyNew)->_REAL.pos, yyt->_REAL.pos)
  11664. return;
  11665. case k_DOUBLE: (* yyNew)->_DOUBLE = yyt->_DOUBLE;
  11666. copytPosition ((* yyNew)->_DOUBLE.pos, yyt->_DOUBLE.pos)
  11667. return;
  11668. case k_BOOLEAN: (* yyNew)->_BOOLEAN = yyt->_BOOLEAN;
  11669. copytPosition ((* yyNew)->_BOOLEAN.pos, yyt->_BOOLEAN.pos)
  11670. return;
  11671. case k_STRING: (* yyNew)->_STRING = yyt->_STRING;
  11672. copytPosition ((* yyNew)->_STRING.pos, yyt->_STRING.pos)
  11673. return;
  11674. case k_BIT: (* yyNew)->_BIT = yyt->_BIT;
  11675. copytPosition ((* yyNew)->_BIT.pos, yyt->_BIT.pos)
  11676. return;
  11677. case k_NONE: (* yyNew)->_NONE = yyt->_NONE;
  11678. copytPosition ((* yyNew)->_NONE.pos, yyt->_NONE.pos)
  11679. return;
  11680. case kBitseq: (* yyNew)->Bitseq = yyt->Bitseq;
  11681. copytStringRef ((* yyNew)->Bitseq.literal, yyt->Bitseq.literal)
  11682. copytPosition ((* yyNew)->Bitseq.pos, yyt->Bitseq.pos)
  11683. return;
  11684. case kString: (* yyNew)->String = yyt->String;
  11685. copytStringRef ((* yyNew)->String.string, yyt->String.string)
  11686. copytPosition ((* yyNew)->String.pos, yyt->String.pos)
  11687. return;
  11688. case kString0: (* yyNew)->String0 = yyt->String0;
  11689. return;
  11690. case kEntity: (* yyNew)->Entity = yyt->Entity;
  11691. return;
  11692. case kEntity0: (* yyNew)->Entity0 = yyt->Entity0;
  11693. return;
  11694. case kCurrent: (* yyNew)->Current = yyt->Current;
  11695. copytPosition ((* yyNew)->Current.pos, yyt->Current.pos)
  11696. return;
  11697. case kResult: (* yyNew)->Result = yyt->Result;
  11698. copytPosition ((* yyNew)->Result.pos, yyt->Result.pos)
  11699. return;
  11700. case kId: (* yyNew)->Id = yyt->Id;
  11701. copytIdent ((* yyNew)->Id.ident, yyt->Id.ident)
  11702. copytPosition ((* yyNew)->Id.pos, yyt->Id.pos)
  11703. return;
  11704.   default: ;
  11705.   }
  11706.  }
  11707. }
  11708.  
  11709. tTree CopyTree
  11710. # if defined __STDC__ | defined __cplusplus
  11711.  (tTree yyt)
  11712. # else
  11713.  (yyt) tTree yyt;
  11714. # endif
  11715. {
  11716.  tTree yyNew;
  11717.  yyMark (yyt);
  11718.  yyOldToNewCount = 0;
  11719.  yyCopyTree (yyt, & yyNew);
  11720.  return yyNew;
  11721. }
  11722.  
  11723. static bool yyCheckTree ARGS((tTree yyt));
  11724.  
  11725. bool CheckTree
  11726. # if defined __STDC__ | defined __cplusplus
  11727.  (tTree yyt)
  11728. # else
  11729.  (yyt) tTree yyt;
  11730. # endif
  11731. {
  11732.  yyMark (yyt);
  11733.  return yyCheckTree (yyt);
  11734. }
  11735.  
  11736. static bool yyCheckChild
  11737. # if defined __STDC__ | defined __cplusplus
  11738.  (tTree yyParent, tTree yyyChild, Tree_tKind yyType, char * yySelector)
  11739. # else
  11740.  (yyParent, yyyChild, yyType, yySelector)
  11741.  tTree yyParent, yyyChild;
  11742.  Tree_tKind yyType;
  11743.  char * yySelector;
  11744. # endif
  11745. {
  11746.  bool yySuccess = Tree_IsType (yyyChild, yyType);
  11747.  if (! yySuccess) {
  11748.   (void) fputs ("CheckTree: parent = ", stderr);
  11749.   WriteTreeNode (stderr, yyParent);
  11750.   (void) fprintf (stderr, "\nselector: %s child = ", yySelector);
  11751.   WriteTreeNode (stderr, yyyChild);
  11752.   (void) fputc ('\n', stderr);
  11753.  }
  11754.  return yyCheckTree (yyyChild) && yySuccess;
  11755. }
  11756.  
  11757. static bool yyCheckTree
  11758. # if defined __STDC__ | defined __cplusplus
  11759.  (tTree yyt)
  11760. # else
  11761.  (yyt) tTree yyt;
  11762. # endif
  11763. {
  11764.  bool yyResult;
  11765.  if (yyt == NoTree) return false;
  11766.  else if (yyt->yyHead.yyMark == 0) return true;
  11767.  yyt->yyHead.yyMark = 0;
  11768.  
  11769.  yyResult = true;
  11770.  switch (yyt->Kind) {
  11771. case kEiffel:
  11772. yyResult = yyCheckChild (yyt, yyt->Eiffel.Classes, kClasses, "Classes") && yyResult;
  11773. break;
  11774. case kClasses1:
  11775. yyResult = yyCheckChild (yyt, yyt->Classes1.Class_declaration, kClass_declaration, "Class_declaration") && yyResult;
  11776. yyResult = yyCheckChild (yyt, yyt->Classes1.Classes, kClasses, "Classes") && yyResult;
  11777. break;
  11778. case kClass_declaration:
  11779. yyResult = yyCheckChild (yyt, yyt->Class_declaration.Indexing, kIndex_list, "Indexing") && yyResult;
  11780. yyResult = yyCheckChild (yyt, yyt->Class_declaration.Class_header, kClass_header, "Class_header") && yyResult;
  11781. yyResult = yyCheckChild (yyt, yyt->Class_declaration.Formal_generics, kFormal_generics, "Formal_generics") && yyResult;
  11782. yyResult = yyCheckChild (yyt, yyt->Class_declaration.Obsolete, kManifest_constant, "Obsolete") && yyResult;
  11783. yyResult = yyCheckChild (yyt, yyt->Class_declaration.Inheritance, kParent_list, "Inheritance") && yyResult;
  11784. yyResult = yyCheckChild (yyt, yyt->Class_declaration.Creators, kCreators, "Creators") && yyResult;
  11785. yyResult = yyCheckChild (yyt, yyt->Class_declaration.Features, kFeatures, "Features") && yyResult;
  11786. yyResult = yyCheckChild (yyt, yyt->Class_declaration.Invariant, kCondition, "Invariant") && yyResult;
  11787. break;
  11788. case kIndex_list1:
  11789. yyResult = yyCheckChild (yyt, yyt->Index_list1.Index_clause, kIndex_clause, "Index_clause") && yyResult;
  11790. yyResult = yyCheckChild (yyt, yyt->Index_list1.Index_list, kIndex_list, "Index_list") && yyResult;
  11791. break;
  11792. case kIndex_clause:
  11793. yyResult = yyCheckChild (yyt, yyt->Index_clause.Index, kManifest_constant, "Index") && yyResult;
  11794. yyResult = yyCheckChild (yyt, yyt->Index_clause.Index_terms, kList, "Index_terms") && yyResult;
  11795. break;
  11796. case kClass:
  11797. yyResult = yyCheckChild (yyt, yyt->Class.Name, kManifest_constant, "Name") && yyResult;
  11798. break;
  11799. case kExpanded_class:
  11800. yyResult = yyCheckChild (yyt, yyt->Expanded_class.Name, kManifest_constant, "Name") && yyResult;
  11801. break;
  11802. case kDeferred_class:
  11803. yyResult = yyCheckChild (yyt, yyt->Deferred_class.Name, kManifest_constant, "Name") && yyResult;
  11804. break;
  11805. case kFeatures1:
  11806. yyResult = yyCheckChild (yyt, yyt->Features1.Feature_clause, kFeature_clause, "Feature_clause") && yyResult;
  11807. yyResult = yyCheckChild (yyt, yyt->Features1.Features, kFeatures, "Features") && yyResult;
  11808. break;
  11809. case kFeature_clause:
  11810. yyResult = yyCheckChild (yyt, yyt->Feature_clause.Clients, kClients, "Clients") && yyResult;
  11811. yyResult = yyCheckChild (yyt, yyt->Feature_clause.Feature_decls, kFeature_decls, "Feature_decls") && yyResult;
  11812. break;
  11813. case kClients1:
  11814. yyResult = yyCheckChild (yyt, yyt->Clients1.List, kList, "List") && yyResult;
  11815. break;
  11816. case kFeature_decls1:
  11817. yyResult = yyCheckChild (yyt, yyt->Feature_decls1.Feature_decl, kFeature_decl, "Feature_decl") && yyResult;
  11818. yyResult = yyCheckChild (yyt, yyt->Feature_decls1.Feature_decls, kFeature_decls, "Feature_decls") && yyResult;
  11819. break;
  11820. case kFeature_decl:
  11821. yyResult = yyCheckChild (yyt, yyt->Feature_decl.New_feature_list, kNew_feature_list, "New_feature_list") && yyResult;
  11822. yyResult = yyCheckChild (yyt, yyt->Feature_decl.Declaration_body, kDeclaration_body, "Declaration_body") && yyResult;
  11823. break;
  11824. case kDeclaration_body:
  11825. yyResult = yyCheckChild (yyt, yyt->Declaration_body.Formal_args, kFormal_args, "Formal_args") && yyResult;
  11826. yyResult = yyCheckChild (yyt, yyt->Declaration_body.Type_mark, kType, "Type_mark") && yyResult;
  11827. yyResult = yyCheckChild (yyt, yyt->Declaration_body.Const_or_routine, kConst_or_routine, "Const_or_routine") && yyResult;
  11828. break;
  11829. case kM_const:
  11830. yyResult = yyCheckChild (yyt, yyt->M_const.Manifest_constant, kManifest_constant, "Manifest_constant") && yyResult;
  11831. break;
  11832. case kRoutine:
  11833. yyResult = yyCheckChild (yyt, yyt->Routine.Obsolete, kManifest_constant, "Obsolete") && yyResult;
  11834. yyResult = yyCheckChild (yyt, yyt->Routine.Precondition, kCondition, "Precondition") && yyResult;
  11835. yyResult = yyCheckChild (yyt, yyt->Routine.Local_decls, kFormal_args, "Local_decls") && yyResult;
  11836. yyResult = yyCheckChild (yyt, yyt->Routine.Routine_body, kRoutine_body, "Routine_body") && yyResult;
  11837. yyResult = yyCheckChild (yyt, yyt->Routine.Postcondition, kCondition, "Postcondition") && yyResult;
  11838. yyResult = yyCheckChild (yyt, yyt->Routine.Rescue, kCompound, "Rescue") && yyResult;
  11839. break;
  11840. case kParent_list1:
  11841. yyResult = yyCheckChild (yyt, yyt->Parent_list1.Parent, kParent, "Parent") && yyResult;
  11842. yyResult = yyCheckChild (yyt, yyt->Parent_list1.Parent_list, kParent_list, "Parent_list") && yyResult;
  11843. break;
  11844. case kParent:
  11845. yyResult = yyCheckChild (yyt, yyt->Parent.Class_type, kClass_type, "Class_type") && yyResult;
  11846. yyResult = yyCheckChild (yyt, yyt->Parent.Feature_adaptation, kFeature_adaptation, "Feature_adaptation") && yyResult;
  11847. break;
  11848. case kFeature_adaptation1:
  11849. yyResult = yyCheckChild (yyt, yyt->Feature_adaptation1.Rename, kRename_list, "Rename") && yyResult;
  11850. yyResult = yyCheckChild (yyt, yyt->Feature_adaptation1.New_export, kNew_export_list, "New_export") && yyResult;
  11851. yyResult = yyCheckChild (yyt, yyt->Feature_adaptation1.Undefine, kFeature_list, "Undefine") && yyResult;
  11852. yyResult = yyCheckChild (yyt, yyt->Feature_adaptation1.Redefine, kFeature_list, "Redefine") && yyResult;
  11853. yyResult = yyCheckChild (yyt, yyt->Feature_adaptation1.Select, kFeature_list, "Select") && yyResult;
  11854. break;
  11855. case kRename_list1:
  11856. yyResult = yyCheckChild (yyt, yyt->Rename_list1.Rename_pair, kRename_pair, "Rename_pair") && yyResult;
  11857. yyResult = yyCheckChild (yyt, yyt->Rename_list1.Rename_list, kRename_list, "Rename_list") && yyResult;
  11858. break;
  11859. case kRename_pair:
  11860. yyResult = yyCheckChild (yyt, yyt->Rename_pair.Name1, kFeature_name, "Name1") && yyResult;
  11861. yyResult = yyCheckChild (yyt, yyt->Rename_pair.Name2, kFeature_name, "Name2") && yyResult;
  11862. break;
  11863. case kCreators1:
  11864. yyResult = yyCheckChild (yyt, yyt->Creators1.Creation_clause, kCreation_clause, "Creation_clause") && yyResult;
  11865. yyResult = yyCheckChild (yyt, yyt->Creators1.Creators, kCreators, "Creators") && yyResult;
  11866. break;
  11867. case kCreation_clause:
  11868. yyResult = yyCheckChild (yyt, yyt->Creation_clause.Clients, kClients, "Clients") && yyResult;
  11869. yyResult = yyCheckChild (yyt, yyt->Creation_clause.Feature_list, kFeature_list, "Feature_list") && yyResult;
  11870. break;
  11871. case kNew_feature_list1:
  11872. yyResult = yyCheckChild (yyt, yyt->New_feature_list1.Feature_name, kFeature_name, "Feature_name") && yyResult;
  11873. yyResult = yyCheckChild (yyt, yyt->New_feature_list1.New_feature_list, kNew_feature_list, "New_feature_list") && yyResult;
  11874. break;
  11875. case kFrozen:
  11876. yyResult = yyCheckChild (yyt, yyt->Frozen.Feature_name, kFeature_name, "Feature_name") && yyResult;
  11877. break;
  11878. case kIdent_name:
  11879. yyResult = yyCheckChild (yyt, yyt->Ident_name.Id, kId, "Id") && yyResult;
  11880. break;
  11881. case kPrefix:
  11882. yyResult = yyCheckChild (yyt, yyt->Prefix.Op_name, kOp_name, "Op_name") && yyResult;
  11883. break;
  11884. case kInfix:
  11885. yyResult = yyCheckChild (yyt, yyt->Infix.Op_name, kOp_name, "Op_name") && yyResult;
  11886. break;
  11887. case kNew_export_list1:
  11888. yyResult = yyCheckChild (yyt, yyt->New_export_list1.New_export_item, kNew_export_item, "New_export_item") && yyResult;
  11889. yyResult = yyCheckChild (yyt, yyt->New_export_list1.New_export_list, kNew_export_list, "New_export_list") && yyResult;
  11890. break;
  11891. case kNew_export_item:
  11892. yyResult = yyCheckChild (yyt, yyt->New_export_item.Clients, kClients, "Clients") && yyResult;
  11893. yyResult = yyCheckChild (yyt, yyt->New_export_item.Feature_set, kFeature_list, "Feature_set") && yyResult;
  11894. break;
  11895. case kFeature_list1:
  11896. yyResult = yyCheckChild (yyt, yyt->Feature_list1.Feature_name, kFeature_name, "Feature_name") && yyResult;
  11897. yyResult = yyCheckChild (yyt, yyt->Feature_list1.Feature_list, kFeature_list, "Feature_list") && yyResult;
  11898. break;
  11899. case kFormal_args1:
  11900. yyResult = yyCheckChild (yyt, yyt->Formal_args1.Entity_decl_group, kEntity_decl_group, "Entity_decl_group") && yyResult;
  11901. yyResult = yyCheckChild (yyt, yyt->Formal_args1.Formal_args, kFormal_args, "Formal_args") && yyResult;
  11902. break;
  11903. case kDo_body:
  11904. yyResult = yyCheckChild (yyt, yyt->Do_body.Compound, kCompound, "Compound") && yyResult;
  11905. break;
  11906. case kOnce_body:
  11907. yyResult = yyCheckChild (yyt, yyt->Once_body.Compound, kCompound, "Compound") && yyResult;
  11908. break;
  11909. case kExternal:
  11910. yyResult = yyCheckChild (yyt, yyt->External.Lang1, kString, "Lang1") && yyResult;
  11911. yyResult = yyCheckChild (yyt, yyt->External.Lang2, kManifest_constant, "Lang2") && yyResult;
  11912. break;
  11913. case kEntity_decl_group:
  11914. yyResult = yyCheckChild (yyt, yyt->Entity_decl_group.Id_list, kList, "Id_list") && yyResult;
  11915. yyResult = yyCheckChild (yyt, yyt->Entity_decl_group.Type_mark, kType, "Type_mark") && yyResult;
  11916. break;
  11917. case kFormal_generics1:
  11918. yyResult = yyCheckChild (yyt, yyt->Formal_generics1.Formal_generic, kFormal_generic, "Formal_generic") && yyResult;
  11919. yyResult = yyCheckChild (yyt, yyt->Formal_generics1.Formal_generics, kFormal_generics, "Formal_generics") && yyResult;
  11920. break;
  11921. case kFormal_generic:
  11922. yyResult = yyCheckChild (yyt, yyt->Formal_generic.Id, kManifest_constant, "Id") && yyResult;
  11923. yyResult = yyCheckChild (yyt, yyt->Formal_generic.Constraint, kConstraint, "Constraint") && yyResult;
  11924. break;
  11925. case kConstraint1:
  11926. yyResult = yyCheckChild (yyt, yyt->Constraint1.Class_type, kClass_type, "Class_type") && yyResult;
  11927. break;
  11928. case kCompound1:
  11929. yyResult = yyCheckChild (yyt, yyt->Compound1.Instruction, kInstruction, "Instruction") && yyResult;
  11930. yyResult = yyCheckChild (yyt, yyt->Compound1.Compound, kCompound, "Compound") && yyResult;
  11931. break;
  11932. case kThen_part_list1:
  11933. yyResult = yyCheckChild (yyt, yyt->Then_part_list1.Then_part, kThen_part, "Then_part") && yyResult;
  11934. yyResult = yyCheckChild (yyt, yyt->Then_part_list1.Then_part_list, kThen_part_list, "Then_part_list") && yyResult;
  11935. break;
  11936. case kThen_part:
  11937. yyResult = yyCheckChild (yyt, yyt->Then_part.Guard, kExpression, "Guard") && yyResult;
  11938. yyResult = yyCheckChild (yyt, yyt->Then_part.Compound, kCompound, "Compound") && yyResult;
  11939. break;
  11940. case kWhen_part_list1:
  11941. yyResult = yyCheckChild (yyt, yyt->When_part_list1.When_part, kWhen_part, "When_part") && yyResult;
  11942. yyResult = yyCheckChild (yyt, yyt->When_part_list1.When_part_list, kWhen_part_list, "When_part_list") && yyResult;
  11943. break;
  11944. case kWhen_part:
  11945. yyResult = yyCheckChild (yyt, yyt->When_part.Choices, kChoices, "Choices") && yyResult;
  11946. yyResult = yyCheckChild (yyt, yyt->When_part.Compound, kCompound, "Compound") && yyResult;
  11947. break;
  11948. case kChoices1:
  11949. yyResult = yyCheckChild (yyt, yyt->Choices1.Choice, kChoice, "Choice") && yyResult;
  11950. yyResult = yyCheckChild (yyt, yyt->Choices1.Choices, kChoices, "Choices") && yyResult;
  11951. break;
  11952. case kInterval:
  11953. yyResult = yyCheckChild (yyt, yyt->Interval.From, kManifest_constant, "From") && yyResult;
  11954. yyResult = yyCheckChild (yyt, yyt->Interval.To, kManifest_constant, "To") && yyResult;
  11955. break;
  11956. case kVal:
  11957. yyResult = yyCheckChild (yyt, yyt->Val.Manifest_constant, kManifest_constant, "Manifest_constant") && yyResult;
  11958. break;
  11959. case kCreation:
  11960. yyResult = yyCheckChild (yyt, yyt->Creation.Type, kType, "Type") && yyResult;
  11961. yyResult = yyCheckChild (yyt, yyt->Creation.Entity, kEntity, "Entity") && yyResult;
  11962. yyResult = yyCheckChild (yyt, yyt->Creation.Unqual_call, kUnqual_call, "Unqual_call") && yyResult;
  11963. break;
  11964. case kCall_instruct:
  11965. yyResult = yyCheckChild (yyt, yyt->Call_instruct.Call, kCall, "Call") && yyResult;
  11966. break;
  11967. case kAssign:
  11968. yyResult = yyCheckChild (yyt, yyt->Assign.Addr, kEntity, "Addr") && yyResult;
  11969. yyResult = yyCheckChild (yyt, yyt->Assign.Expression, kExpression, "Expression") && yyResult;
  11970. break;
  11971. case kRev_assign:
  11972. yyResult = yyCheckChild (yyt, yyt->Rev_assign.Addr, kEntity, "Addr") && yyResult;
  11973. yyResult = yyCheckChild (yyt, yyt->Rev_assign.Expression, kExpression, "Expression") && yyResult;
  11974. break;
  11975. case kConditional:
  11976. yyResult = yyCheckChild (yyt, yyt->Conditional.Then_part, kThen_part_list, "Then_part") && yyResult;
  11977. yyResult = yyCheckChild (yyt, yyt->Conditional.Else_part, kCompound, "Else_part") && yyResult;
  11978. break;
  11979. case kMulti_branch:
  11980. yyResult = yyCheckChild (yyt, yyt->Multi_branch.Guard, kExpression, "Guard") && yyResult;
  11981. yyResult = yyCheckChild (yyt, yyt->Multi_branch.When_part_list, kWhen_part_list, "When_part_list") && yyResult;
  11982. yyResult = yyCheckChild (yyt, yyt->Multi_branch.Else_part, kCompound, "Else_part") && yyResult;
  11983. break;
  11984. case kLoop:
  11985. yyResult = yyCheckChild (yyt, yyt->Loop.Initialization, kCompound, "Initialization") && yyResult;
  11986. yyResult = yyCheckChild (yyt, yyt->Loop.Invariant, kCondition, "Invariant") && yyResult;
  11987. yyResult = yyCheckChild (yyt, yyt->Loop.Variant, kAssertion_clause, "Variant") && yyResult;
  11988. yyResult = yyCheckChild (yyt, yyt->Loop.Loop_body, kLoop_body, "Loop_body") && yyResult;
  11989. break;
  11990. case kCheck:
  11991. yyResult = yyCheckChild (yyt, yyt->Check.Assertion, kAssertion, "Assertion") && yyResult;
  11992. break;
  11993. case kDebug:
  11994. yyResult = yyCheckChild (yyt, yyt->Debug.Debug_keys, kList, "Debug_keys") && yyResult;
  11995. yyResult = yyCheckChild (yyt, yyt->Debug.Compound, kCompound, "Compound") && yyResult;
  11996. break;
  11997. case kLoop_body1:
  11998. yyResult = yyCheckChild (yyt, yyt->Loop_body1.Exit, kExpression, "Exit") && yyResult;
  11999. yyResult = yyCheckChild (yyt, yyt->Loop_body1.Compound, kCompound, "Compound") && yyResult;
  12000. break;
  12001. case kClass_type:
  12002. yyResult = yyCheckChild (yyt, yyt->Class_type.Id, kId, "Id") && yyResult;
  12003. yyResult = yyCheckChild (yyt, yyt->Class_type.Actual_generics, kActual_generics, "Actual_generics") && yyResult;
  12004. break;
  12005. case kClass_type_expanded:
  12006. yyResult = yyCheckChild (yyt, yyt->Class_type_expanded.Id, kId, "Id") && yyResult;
  12007. yyResult = yyCheckChild (yyt, yyt->Class_type_expanded.Actual_generics, kActual_generics, "Actual_generics") && yyResult;
  12008. break;
  12009. case kBit_type:
  12010. yyResult = yyCheckChild (yyt, yyt->Bit_type.Manifest_constant, kManifest_constant, "Manifest_constant") && yyResult;
  12011. break;
  12012. case kSimple_type:
  12013. yyResult = yyCheckChild (yyt, yyt->Simple_type.Manifest_constant, kManifest_constant, "Manifest_constant") && yyResult;
  12014. break;
  12015. case kAnchored:
  12016. yyResult = yyCheckChild (yyt, yyt->Anchored.Entity, kEntity, "Entity") && yyResult;
  12017. break;
  12018. case kActual_generics1:
  12019. yyResult = yyCheckChild (yyt, yyt->Actual_generics1.Type_list, kType_list, "Type_list") && yyResult;
  12020. break;
  12021. case kCondition1:
  12022. yyResult = yyCheckChild (yyt, yyt->Condition1.Assertion, kAssertion, "Assertion") && yyResult;
  12023. break;
  12024. case kAssertion1:
  12025. yyResult = yyCheckChild (yyt, yyt->Assertion1.Assertion_clause, kAssertion_clause, "Assertion_clause") && yyResult;
  12026. yyResult = yyCheckChild (yyt, yyt->Assertion1.Assertion, kAssertion, "Assertion") && yyResult;
  12027. break;
  12028. case kAssertion_clause1:
  12029. yyResult = yyCheckChild (yyt, yyt->Assertion_clause1.Tag, kManifest_constant, "Tag") && yyResult;
  12030. yyResult = yyCheckChild (yyt, yyt->Assertion_clause1.Expression, kExpression, "Expression") && yyResult;
  12031. break;
  12032. case kType_list1:
  12033. yyResult = yyCheckChild (yyt, yyt->Type_list1.Type, kType, "Type") && yyResult;
  12034. yyResult = yyCheckChild (yyt, yyt->Type_list1.Type_list, kType_list, "Type_list") && yyResult;
  12035. break;
  12036. case kCall_chain1:
  12037. yyResult = yyCheckChild (yyt, yyt->Call_chain1.Unqual_call, kUnqual_call, "Unqual_call") && yyResult;
  12038. yyResult = yyCheckChild (yyt, yyt->Call_chain1.Call_chain, kCall_chain, "Call_chain") && yyResult;
  12039. break;
  12040. case kUnqual_call1:
  12041. yyResult = yyCheckChild (yyt, yyt->Unqual_call1.Entity, kEntity, "Entity") && yyResult;
  12042. yyResult = yyCheckChild (yyt, yyt->Unqual_call1.Actuals, kActuals, "Actuals") && yyResult;
  12043. break;
  12044. case kActuals1:
  12045. yyResult = yyCheckChild (yyt, yyt->Actuals1.Actual_list, kActual_list, "Actual_list") && yyResult;
  12046. break;
  12047. case kActual_list1:
  12048. yyResult = yyCheckChild (yyt, yyt->Actual_list1.Actual, kActual, "Actual") && yyResult;
  12049. yyResult = yyCheckChild (yyt, yyt->Actual_list1.Actual_list, kActual_list, "Actual_list") && yyResult;
  12050. break;
  12051. case kAddr:
  12052. yyResult = yyCheckChild (yyt, yyt->Addr.Entity, kEntity, "Entity") && yyResult;
  12053. break;
  12054. case kSimple_expr:
  12055. yyResult = yyCheckChild (yyt, yyt->Simple_expr.Manifest_constant, kManifest_constant, "Manifest_constant") && yyResult;
  12056. break;
  12057. case kCall:
  12058. yyResult = yyCheckChild (yyt, yyt->Call.Qual, kExpression, "Qual") && yyResult;
  12059. yyResult = yyCheckChild (yyt, yyt->Call.Call_chain, kCall_chain, "Call_chain") && yyResult;
  12060. break;
  12061. case kBin_expr:
  12062. yyResult = yyCheckChild (yyt, yyt->Bin_expr.Lop, kExpression, "Lop") && yyResult;
  12063. yyResult = yyCheckChild (yyt, yyt->Bin_expr.Op, kOp, "Op") && yyResult;
  12064. yyResult = yyCheckChild (yyt, yyt->Bin_expr.Rop, kExpression, "Rop") && yyResult;
  12065. break;
  12066. case kUn_expr:
  12067. yyResult = yyCheckChild (yyt, yyt->Un_expr.Op, kOp, "Op") && yyResult;
  12068. yyResult = yyCheckChild (yyt, yyt->Un_expr.Expression, kExpression, "Expression") && yyResult;
  12069. break;
  12070. case kParenth:
  12071. yyResult = yyCheckChild (yyt, yyt->Parenth.Expression, kExpression, "Expression") && yyResult;
  12072. break;
  12073. case kManifest_array1:
  12074. yyResult = yyCheckChild (yyt, yyt->Manifest_array1.Expression, kExpression, "Expression") && yyResult;
  12075. yyResult = yyCheckChild (yyt, yyt->Manifest_array1.Manifest_array, kManifest_array, "Manifest_array") && yyResult;
  12076. break;
  12077. case kOld:
  12078. yyResult = yyCheckChild (yyt, yyt->Old.Expression, kExpression, "Expression") && yyResult;
  12079. break;
  12080. case kStrip:
  12081. yyResult = yyCheckChild (yyt, yyt->Strip.List, kList, "List") && yyResult;
  12082. break;
  12083. case klist:
  12084. yyResult = yyCheckChild (yyt, yyt->list.Manifest_constant, kManifest_constant, "Manifest_constant") && yyResult;
  12085. yyResult = yyCheckChild (yyt, yyt->list.List, kList, "List") && yyResult;
  12086. break;
  12087. case kInt:
  12088. yyResult = yyCheckChild (yyt, yyt->Int.Sign, kOper, "Sign") && yyResult;
  12089. break;
  12090. case kReal:
  12091. yyResult = yyCheckChild (yyt, yyt->Real.Sign, kOper, "Sign") && yyResult;
  12092. break;
  12093.  default: ;
  12094.  }
  12095.  return yyResult;
  12096. }
  12097.  
  12098. # define yyyWrite    1
  12099. # define yyyRead    2
  12100. # define yyyQuit    3
  12101.  
  12102. static char yyyString [32], yyCh;
  12103. static int yyLength, yyState;
  12104.  
  12105. static bool yyyIsEqual
  12106. # if defined __STDC__ | defined __cplusplus
  12107.  (char * yya)
  12108. # else
  12109.  (yya) char * yya;
  12110. # endif
  12111. {
  12112.  register int yyi;
  12113.  if (yyLength >= 0 && yyyString [yyLength] == ' ') {
  12114.   if (yyLength != strlen (yya)) return false;
  12115.   for (yyi = 0; yyi < yyLength; yyi ++)
  12116.    if (yyyString [yyi] != yya [yyi]) return false;
  12117.  } else {
  12118.   if (yyLength >= strlen (yya)) return false;
  12119.   for (yyi = 0; yyi <= yyLength; yyi ++)
  12120.    if (yyyString [yyi] != yya [yyi]) return false;
  12121.  }
  12122.  return true;
  12123. }
  12124.  
  12125. void QueryTree
  12126. # if defined __STDC__ | defined __cplusplus
  12127.  (tTree yyt)
  12128. # else
  12129.  (yyt) tTree yyt;
  12130. # endif
  12131. {
  12132.  yyState = yyyWrite;
  12133.  for (;;) {
  12134.   switch (yyState) {
  12135.   case yyyQuit : return;
  12136.   case yyyWrite: WriteTreeNode (stdout, yyt); yyState = yyyRead;
  12137.   case yyyRead : (void) printf ("? "); yyLength = -1; yyCh = getc (stdin);
  12138.    while (yyCh != '\n' && yyCh > 0)
  12139.     { yyyString [++ yyLength] = yyCh; yyCh = getc (stdin); }
  12140.    if (yyCh < 0) { (void) fputs ("QueryTree: eof reached\n", stderr);
  12141.     yyState = yyyQuit; return; }
  12142.    if      (yyyIsEqual ("parent")) { yyState = yyyWrite; return; }
  12143.    else if (yyyIsEqual ("quit"  )) { yyState = yyyQuit ; return; }
  12144.    else if (yyt != NoTree) {
  12145.     switch (yyt->Kind) {
  12146. case kEiffel: if (false) ;
  12147. else if (yyyIsEqual ("Classes")) QueryTree (yyt->Eiffel.Classes);
  12148. break;
  12149. case kClasses1: if (false) ;
  12150. else if (yyyIsEqual ("Class_declaration")) QueryTree (yyt->Classes1.Class_declaration);
  12151. else if (yyyIsEqual ("Classes")) QueryTree (yyt->Classes1.Classes);
  12152. break;
  12153. case kClass_declaration: if (false) ;
  12154. else if (yyyIsEqual ("Indexing")) QueryTree (yyt->Class_declaration.Indexing);
  12155. else if (yyyIsEqual ("Class_header")) QueryTree (yyt->Class_declaration.Class_header);
  12156. else if (yyyIsEqual ("Formal_generics")) QueryTree (yyt->Class_declaration.Formal_generics);
  12157. else if (yyyIsEqual ("Obsolete")) QueryTree (yyt->Class_declaration.Obsolete);
  12158. else if (yyyIsEqual ("Inheritance")) QueryTree (yyt->Class_declaration.Inheritance);
  12159. else if (yyyIsEqual ("Creators")) QueryTree (yyt->Class_declaration.Creators);
  12160. else if (yyyIsEqual ("Features")) QueryTree (yyt->Class_declaration.Features);
  12161. else if (yyyIsEqual ("Invariant")) QueryTree (yyt->Class_declaration.Invariant);
  12162. break;
  12163. case kIndex_list1: if (false) ;
  12164. else if (yyyIsEqual ("Index_clause")) QueryTree (yyt->Index_list1.Index_clause);
  12165. else if (yyyIsEqual ("Index_list")) QueryTree (yyt->Index_list1.Index_list);
  12166. break;
  12167. case kIndex_clause: if (false) ;
  12168. else if (yyyIsEqual ("Index")) QueryTree (yyt->Index_clause.Index);
  12169. else if (yyyIsEqual ("Index_terms")) QueryTree (yyt->Index_clause.Index_terms);
  12170. break;
  12171. case kClass: if (false) ;
  12172. else if (yyyIsEqual ("Name")) QueryTree (yyt->Class.Name);
  12173. break;
  12174. case kExpanded_class: if (false) ;
  12175. else if (yyyIsEqual ("Name")) QueryTree (yyt->Expanded_class.Name);
  12176. break;
  12177. case kDeferred_class: if (false) ;
  12178. else if (yyyIsEqual ("Name")) QueryTree (yyt->Deferred_class.Name);
  12179. break;
  12180. case kFeatures1: if (false) ;
  12181. else if (yyyIsEqual ("Feature_clause")) QueryTree (yyt->Features1.Feature_clause);
  12182. else if (yyyIsEqual ("Features")) QueryTree (yyt->Features1.Features);
  12183. break;
  12184. case kFeature_clause: if (false) ;
  12185. else if (yyyIsEqual ("Clients")) QueryTree (yyt->Feature_clause.Clients);
  12186. else if (yyyIsEqual ("Feature_decls")) QueryTree (yyt->Feature_clause.Feature_decls);
  12187. break;
  12188. case kClients1: if (false) ;
  12189. else if (yyyIsEqual ("List")) QueryTree (yyt->Clients1.List);
  12190. break;
  12191. case kFeature_decls1: if (false) ;
  12192. else if (yyyIsEqual ("Feature_decl")) QueryTree (yyt->Feature_decls1.Feature_decl);
  12193. else if (yyyIsEqual ("Feature_decls")) QueryTree (yyt->Feature_decls1.Feature_decls);
  12194. break;
  12195. case kFeature_decl: if (false) ;
  12196. else if (yyyIsEqual ("New_feature_list")) QueryTree (yyt->Feature_decl.New_feature_list);
  12197. else if (yyyIsEqual ("Declaration_body")) QueryTree (yyt->Feature_decl.Declaration_body);
  12198. break;
  12199. case kDeclaration_body: if (false) ;
  12200. else if (yyyIsEqual ("Formal_args")) QueryTree (yyt->Declaration_body.Formal_args);
  12201. else if (yyyIsEqual ("Type_mark")) QueryTree (yyt->Declaration_body.Type_mark);
  12202. else if (yyyIsEqual ("Const_or_routine")) QueryTree (yyt->Declaration_body.Const_or_routine);
  12203. break;
  12204. case kM_const: if (false) ;
  12205. else if (yyyIsEqual ("Manifest_constant")) QueryTree (yyt->M_const.Manifest_constant);
  12206. break;
  12207. case kRoutine: if (false) ;
  12208. else if (yyyIsEqual ("Obsolete")) QueryTree (yyt->Routine.Obsolete);
  12209. else if (yyyIsEqual ("Precondition")) QueryTree (yyt->Routine.Precondition);
  12210. else if (yyyIsEqual ("Local_decls")) QueryTree (yyt->Routine.Local_decls);
  12211. else if (yyyIsEqual ("Routine_body")) QueryTree (yyt->Routine.Routine_body);
  12212. else if (yyyIsEqual ("Postcondition")) QueryTree (yyt->Routine.Postcondition);
  12213. else if (yyyIsEqual ("Rescue")) QueryTree (yyt->Routine.Rescue);
  12214. break;
  12215. case kParent_list1: if (false) ;
  12216. else if (yyyIsEqual ("Parent")) QueryTree (yyt->Parent_list1.Parent);
  12217. else if (yyyIsEqual ("Parent_list")) QueryTree (yyt->Parent_list1.Parent_list);
  12218. break;
  12219. case kParent: if (false) ;
  12220. else if (yyyIsEqual ("Class_type")) QueryTree (yyt->Parent.Class_type);
  12221. else if (yyyIsEqual ("Feature_adaptation")) QueryTree (yyt->Parent.Feature_adaptation);
  12222. break;
  12223. case kFeature_adaptation1: if (false) ;
  12224. else if (yyyIsEqual ("Rename")) QueryTree (yyt->Feature_adaptation1.Rename);
  12225. else if (yyyIsEqual ("New_export")) QueryTree (yyt->Feature_adaptation1.New_export);
  12226. else if (yyyIsEqual ("Undefine")) QueryTree (yyt->Feature_adaptation1.Undefine);
  12227. else if (yyyIsEqual ("Redefine")) QueryTree (yyt->Feature_adaptation1.Redefine);
  12228. else if (yyyIsEqual ("Select")) QueryTree (yyt->Feature_adaptation1.Select);
  12229. break;
  12230. case kRename_list1: if (false) ;
  12231. else if (yyyIsEqual ("Rename_pair")) QueryTree (yyt->Rename_list1.Rename_pair);
  12232. else if (yyyIsEqual ("Rename_list")) QueryTree (yyt->Rename_list1.Rename_list);
  12233. break;
  12234. case kRename_pair: if (false) ;
  12235. else if (yyyIsEqual ("Name1")) QueryTree (yyt->Rename_pair.Name1);
  12236. else if (yyyIsEqual ("Name2")) QueryTree (yyt->Rename_pair.Name2);
  12237. break;
  12238. case kCreators1: if (false) ;
  12239. else if (yyyIsEqual ("Creation_clause")) QueryTree (yyt->Creators1.Creation_clause);
  12240. else if (yyyIsEqual ("Creators")) QueryTree (yyt->Creators1.Creators);
  12241. break;
  12242. case kCreation_clause: if (false) ;
  12243. else if (yyyIsEqual ("Clients")) QueryTree (yyt->Creation_clause.Clients);
  12244. else if (yyyIsEqual ("Feature_list")) QueryTree (yyt->Creation_clause.Feature_list);
  12245. break;
  12246. case kNew_feature_list1: if (false) ;
  12247. else if (yyyIsEqual ("Feature_name")) QueryTree (yyt->New_feature_list1.Feature_name);
  12248. else if (yyyIsEqual ("New_feature_list")) QueryTree (yyt->New_feature_list1.New_feature_list);
  12249. break;
  12250. case kFrozen: if (false) ;
  12251. else if (yyyIsEqual ("Feature_name")) QueryTree (yyt->Frozen.Feature_name);
  12252. break;
  12253. case kIdent_name: if (false) ;
  12254. else if (yyyIsEqual ("Id")) QueryTree (yyt->Ident_name.Id);
  12255. break;
  12256. case kPrefix: if (false) ;
  12257. else if (yyyIsEqual ("Op_name")) QueryTree (yyt->Prefix.Op_name);
  12258. break;
  12259. case kInfix: if (false) ;
  12260. else if (yyyIsEqual ("Op_name")) QueryTree (yyt->Infix.Op_name);
  12261. break;
  12262. case kNew_export_list1: if (false) ;
  12263. else if (yyyIsEqual ("New_export_item")) QueryTree (yyt->New_export_list1.New_export_item);
  12264. else if (yyyIsEqual ("New_export_list")) QueryTree (yyt->New_export_list1.New_export_list);
  12265. break;
  12266. case kNew_export_item: if (false) ;
  12267. else if (yyyIsEqual ("Clients")) QueryTree (yyt->New_export_item.Clients);
  12268. else if (yyyIsEqual ("Feature_set")) QueryTree (yyt->New_export_item.Feature_set);
  12269. break;
  12270. case kFeature_list1: if (false) ;
  12271. else if (yyyIsEqual ("Feature_name")) QueryTree (yyt->Feature_list1.Feature_name);
  12272. else if (yyyIsEqual ("Feature_list")) QueryTree (yyt->Feature_list1.Feature_list);
  12273. break;
  12274. case kFormal_args1: if (false) ;
  12275. else if (yyyIsEqual ("Entity_decl_group")) QueryTree (yyt->Formal_args1.Entity_decl_group);
  12276. else if (yyyIsEqual ("Formal_args")) QueryTree (yyt->Formal_args1.Formal_args);
  12277. break;
  12278. case kDo_body: if (false) ;
  12279. else if (yyyIsEqual ("Compound")) QueryTree (yyt->Do_body.Compound);
  12280. break;
  12281. case kOnce_body: if (false) ;
  12282. else if (yyyIsEqual ("Compound")) QueryTree (yyt->Once_body.Compound);
  12283. break;
  12284. case kExternal: if (false) ;
  12285. else if (yyyIsEqual ("Lang1")) QueryTree (yyt->External.Lang1);
  12286. else if (yyyIsEqual ("Lang2")) QueryTree (yyt->External.Lang2);
  12287. break;
  12288. case kEntity_decl_group: if (false) ;
  12289. else if (yyyIsEqual ("Id_list")) QueryTree (yyt->Entity_decl_group.Id_list);
  12290. else if (yyyIsEqual ("Type_mark")) QueryTree (yyt->Entity_decl_group.Type_mark);
  12291. break;
  12292. case kFormal_generics1: if (false) ;
  12293. else if (yyyIsEqual ("Formal_generic")) QueryTree (yyt->Formal_generics1.Formal_generic);
  12294. else if (yyyIsEqual ("Formal_generics")) QueryTree (yyt->Formal_generics1.Formal_generics);
  12295. break;
  12296. case kFormal_generic: if (false) ;
  12297. else if (yyyIsEqual ("Id")) QueryTree (yyt->Formal_generic.Id);
  12298. else if (yyyIsEqual ("Constraint")) QueryTree (yyt->Formal_generic.Constraint);
  12299. break;
  12300. case kConstraint1: if (false) ;
  12301. else if (yyyIsEqual ("Class_type")) QueryTree (yyt->Constraint1.Class_type);
  12302. break;
  12303. case kCompound1: if (false) ;
  12304. else if (yyyIsEqual ("Instruction")) QueryTree (yyt->Compound1.Instruction);
  12305. else if (yyyIsEqual ("Compound")) QueryTree (yyt->Compound1.Compound);
  12306. break;
  12307. case kThen_part_list1: if (false) ;
  12308. else if (yyyIsEqual ("Then_part")) QueryTree (yyt->Then_part_list1.Then_part);
  12309. else if (yyyIsEqual ("Then_part_list")) QueryTree (yyt->Then_part_list1.Then_part_list);
  12310. break;
  12311. case kThen_part: if (false) ;
  12312. else if (yyyIsEqual ("Guard")) QueryTree (yyt->Then_part.Guard);
  12313. else if (yyyIsEqual ("Compound")) QueryTree (yyt->Then_part.Compound);
  12314. break;
  12315. case kWhen_part_list1: if (false) ;
  12316. else if (yyyIsEqual ("When_part")) QueryTree (yyt->When_part_list1.When_part);
  12317. else if (yyyIsEqual ("When_part_list")) QueryTree (yyt->When_part_list1.When_part_list);
  12318. break;
  12319. case kWhen_part: if (false) ;
  12320. else if (yyyIsEqual ("Choices")) QueryTree (yyt->When_part.Choices);
  12321. else if (yyyIsEqual ("Compound")) QueryTree (yyt->When_part.Compound);
  12322. break;
  12323. case kChoices1: if (false) ;
  12324. else if (yyyIsEqual ("Choice")) QueryTree (yyt->Choices1.Choice);
  12325. else if (yyyIsEqual ("Choices")) QueryTree (yyt->Choices1.Choices);
  12326. break;
  12327. case kInterval: if (false) ;
  12328. else if (yyyIsEqual ("From")) QueryTree (yyt->Interval.From);
  12329. else if (yyyIsEqual ("To")) QueryTree (yyt->Interval.To);
  12330. break;
  12331. case kVal: if (false) ;
  12332. else if (yyyIsEqual ("Manifest_constant")) QueryTree (yyt->Val.Manifest_constant);
  12333. break;
  12334. case kCreation: if (false) ;
  12335. else if (yyyIsEqual ("Type")) QueryTree (yyt->Creation.Type);
  12336. else if (yyyIsEqual ("Entity")) QueryTree (yyt->Creation.Entity);
  12337. else if (yyyIsEqual ("Unqual_call")) QueryTree (yyt->Creation.Unqual_call);
  12338. break;
  12339. case kCall_instruct: if (false) ;
  12340. else if (yyyIsEqual ("Call")) QueryTree (yyt->Call_instruct.Call);
  12341. break;
  12342. case kAssign: if (false) ;
  12343. else if (yyyIsEqual ("Addr")) QueryTree (yyt->Assign.Addr);
  12344. else if (yyyIsEqual ("Expression")) QueryTree (yyt->Assign.Expression);
  12345. break;
  12346. case kRev_assign: if (false) ;
  12347. else if (yyyIsEqual ("Addr")) QueryTree (yyt->Rev_assign.Addr);
  12348. else if (yyyIsEqual ("Expression")) QueryTree (yyt->Rev_assign.Expression);
  12349. break;
  12350. case kConditional: if (false) ;
  12351. else if (yyyIsEqual ("Then_part")) QueryTree (yyt->Conditional.Then_part);
  12352. else if (yyyIsEqual ("Else_part")) QueryTree (yyt->Conditional.Else_part);
  12353. break;
  12354. case kMulti_branch: if (false) ;
  12355. else if (yyyIsEqual ("Guard")) QueryTree (yyt->Multi_branch.Guard);
  12356. else if (yyyIsEqual ("When_part_list")) QueryTree (yyt->Multi_branch.When_part_list);
  12357. else if (yyyIsEqual ("Else_part")) QueryTree (yyt->Multi_branch.Else_part);
  12358. break;
  12359. case kLoop: if (false) ;
  12360. else if (yyyIsEqual ("Initialization")) QueryTree (yyt->Loop.Initialization);
  12361. else if (yyyIsEqual ("Invariant")) QueryTree (yyt->Loop.Invariant);
  12362. else if (yyyIsEqual ("Variant")) QueryTree (yyt->Loop.Variant);
  12363. else if (yyyIsEqual ("Loop_body")) QueryTree (yyt->Loop.Loop_body);
  12364. break;
  12365. case kCheck: if (false) ;
  12366. else if (yyyIsEqual ("Assertion")) QueryTree (yyt->Check.Assertion);
  12367. break;
  12368. case kDebug: if (false) ;
  12369. else if (yyyIsEqual ("Debug_keys")) QueryTree (yyt->Debug.Debug_keys);
  12370. else if (yyyIsEqual ("Compound")) QueryTree (yyt->Debug.Compound);
  12371. break;
  12372. case kLoop_body1: if (false) ;
  12373. else if (yyyIsEqual ("Exit")) QueryTree (yyt->Loop_body1.Exit);
  12374. else if (yyyIsEqual ("Compound")) QueryTree (yyt->Loop_body1.Compound);
  12375. break;
  12376. case kClass_type: if (false) ;
  12377. else if (yyyIsEqual ("Id")) QueryTree (yyt->Class_type.Id);
  12378. else if (yyyIsEqual ("Actual_generics")) QueryTree (yyt->Class_type.Actual_generics);
  12379. break;
  12380. case kClass_type_expanded: if (false) ;
  12381. else if (yyyIsEqual ("Id")) QueryTree (yyt->Class_type_expanded.Id);
  12382. else if (yyyIsEqual ("Actual_generics")) QueryTree (yyt->Class_type_expanded.Actual_generics);
  12383. break;
  12384. case kBit_type: if (false) ;
  12385. else if (yyyIsEqual ("Manifest_constant")) QueryTree (yyt->Bit_type.Manifest_constant);
  12386. break;
  12387. case kSimple_type: if (false) ;
  12388. else if (yyyIsEqual ("Manifest_constant")) QueryTree (yyt->Simple_type.Manifest_constant);
  12389. break;
  12390. case kAnchored: if (false) ;
  12391. else if (yyyIsEqual ("Entity")) QueryTree (yyt->Anchored.Entity);
  12392. break;
  12393. case kActual_generics1: if (false) ;
  12394. else if (yyyIsEqual ("Type_list")) QueryTree (yyt->Actual_generics1.Type_list);
  12395. break;
  12396. case kCondition1: if (false) ;
  12397. else if (yyyIsEqual ("Assertion")) QueryTree (yyt->Condition1.Assertion);
  12398. break;
  12399. case kAssertion1: if (false) ;
  12400. else if (yyyIsEqual ("Assertion_clause")) QueryTree (yyt->Assertion1.Assertion_clause);
  12401. else if (yyyIsEqual ("Assertion")) QueryTree (yyt->Assertion1.Assertion);
  12402. break;
  12403. case kAssertion_clause1: if (false) ;
  12404. else if (yyyIsEqual ("Tag")) QueryTree (yyt->Assertion_clause1.Tag);
  12405. else if (yyyIsEqual ("Expression")) QueryTree (yyt->Assertion_clause1.Expression);
  12406. break;
  12407. case kType_list1: if (false) ;
  12408. else if (yyyIsEqual ("Type")) QueryTree (yyt->Type_list1.Type);
  12409. else if (yyyIsEqual ("Type_list")) QueryTree (yyt->Type_list1.Type_list);
  12410. break;
  12411. case kCall_chain1: if (false) ;
  12412. else if (yyyIsEqual ("Unqual_call")) QueryTree (yyt->Call_chain1.Unqual_call);
  12413. else if (yyyIsEqual ("Call_chain")) QueryTree (yyt->Call_chain1.Call_chain);
  12414. break;
  12415. case kUnqual_call1: if (false) ;
  12416. else if (yyyIsEqual ("Entity")) QueryTree (yyt->Unqual_call1.Entity);
  12417. else if (yyyIsEqual ("Actuals")) QueryTree (yyt->Unqual_call1.Actuals);
  12418. break;
  12419. case kActuals1: if (false) ;
  12420. else if (yyyIsEqual ("Actual_list")) QueryTree (yyt->Actuals1.Actual_list);
  12421. break;
  12422. case kActual_list1: if (false) ;
  12423. else if (yyyIsEqual ("Actual")) QueryTree (yyt->Actual_list1.Actual);
  12424. else if (yyyIsEqual ("Actual_list")) QueryTree (yyt->Actual_list1.Actual_list);
  12425. break;
  12426. case kAddr: if (false) ;
  12427. else if (yyyIsEqual ("Entity")) QueryTree (yyt->Addr.Entity);
  12428. break;
  12429. case kSimple_expr: if (false) ;
  12430. else if (yyyIsEqual ("Manifest_constant")) QueryTree (yyt->Simple_expr.Manifest_constant);
  12431. break;
  12432. case kCall: if (false) ;
  12433. else if (yyyIsEqual ("Qual")) QueryTree (yyt->Call.Qual);
  12434. else if (yyyIsEqual ("Call_chain")) QueryTree (yyt->Call.Call_chain);
  12435. break;
  12436. case kBin_expr: if (false) ;
  12437. else if (yyyIsEqual ("Lop")) QueryTree (yyt->Bin_expr.Lop);
  12438. else if (yyyIsEqual ("Op")) QueryTree (yyt->Bin_expr.Op);
  12439. else if (yyyIsEqual ("Rop")) QueryTree (yyt->Bin_expr.Rop);
  12440. break;
  12441. case kUn_expr: if (false) ;
  12442. else if (yyyIsEqual ("Op")) QueryTree (yyt->Un_expr.Op);
  12443. else if (yyyIsEqual ("Expression")) QueryTree (yyt->Un_expr.Expression);
  12444. break;
  12445. case kParenth: if (false) ;
  12446. else if (yyyIsEqual ("Expression")) QueryTree (yyt->Parenth.Expression);
  12447. break;
  12448. case kManifest_array1: if (false) ;
  12449. else if (yyyIsEqual ("Expression")) QueryTree (yyt->Manifest_array1.Expression);
  12450. else if (yyyIsEqual ("Manifest_array")) QueryTree (yyt->Manifest_array1.Manifest_array);
  12451. break;
  12452. case kOld: if (false) ;
  12453. else if (yyyIsEqual ("Expression")) QueryTree (yyt->Old.Expression);
  12454. break;
  12455. case kStrip: if (false) ;
  12456. else if (yyyIsEqual ("List")) QueryTree (yyt->Strip.List);
  12457. break;
  12458. case klist: if (false) ;
  12459. else if (yyyIsEqual ("Manifest_constant")) QueryTree (yyt->list.Manifest_constant);
  12460. else if (yyyIsEqual ("List")) QueryTree (yyt->list.List);
  12461. break;
  12462. case kInt: if (false) ;
  12463. else if (yyyIsEqual ("Sign")) QueryTree (yyt->Int.Sign);
  12464. break;
  12465. case kReal: if (false) ;
  12466. else if (yyyIsEqual ("Sign")) QueryTree (yyt->Real.Sign);
  12467. break;
  12468.     default: ;
  12469.     }
  12470.    }
  12471.   }
  12472.  }
  12473. }
  12474.  
  12475. bool IsEqualTree
  12476. # if defined __STDC__ | defined __cplusplus
  12477.  (tTree yyt1, tTree yyt2)
  12478. # else
  12479.  (yyt1, yyt2) tTree yyt1, yyt2;
  12480. # endif
  12481. {
  12482.  if (yyt1 == NoTree && yyt2 == NoTree) return true;
  12483.  if (yyt1 == NoTree || yyt2 == NoTree || yyt1->Kind != yyt2->Kind) return false;
  12484.  switch (yyt1->Kind) {
  12485. case kEiffel: return true
  12486. && equaltTree (yyt1->Eiffel.Classes, yyt2->Eiffel.Classes)
  12487. ;
  12488. case kClasses1: return true
  12489. && equaltTree (yyt1->Classes1.Class_declaration, yyt2->Classes1.Class_declaration)
  12490. && equaltTree (yyt1->Classes1.Classes, yyt2->Classes1.Classes)
  12491. ;
  12492. case kClass_declaration: return true
  12493. && equaltTree (yyt1->Class_declaration.Indexing, yyt2->Class_declaration.Indexing)
  12494. && equaltTree (yyt1->Class_declaration.Class_header, yyt2->Class_declaration.Class_header)
  12495. && equaltTree (yyt1->Class_declaration.Formal_generics, yyt2->Class_declaration.Formal_generics)
  12496. && equaltTree (yyt1->Class_declaration.Obsolete, yyt2->Class_declaration.Obsolete)
  12497. && equaltTree (yyt1->Class_declaration.Inheritance, yyt2->Class_declaration.Inheritance)
  12498. && equaltTree (yyt1->Class_declaration.Creators, yyt2->Class_declaration.Creators)
  12499. && equaltTree (yyt1->Class_declaration.Features, yyt2->Class_declaration.Features)
  12500. && equaltTree (yyt1->Class_declaration.Invariant, yyt2->Class_declaration.Invariant)
  12501. && (equaltStringRef (yyt1->Class_declaration.comment, yyt2->Class_declaration.comment))
  12502. ;
  12503. case kIndex_list1: return true
  12504. && equaltTree (yyt1->Index_list1.Index_clause, yyt2->Index_list1.Index_clause)
  12505. && equaltTree (yyt1->Index_list1.Index_list, yyt2->Index_list1.Index_list)
  12506. ;
  12507. case kIndex_clause: return true
  12508. && equaltTree (yyt1->Index_clause.Index, yyt2->Index_clause.Index)
  12509. && equaltTree (yyt1->Index_clause.Index_terms, yyt2->Index_clause.Index_terms)
  12510. ;
  12511. case kClass: return true
  12512. && equaltTree (yyt1->Class.Name, yyt2->Class.Name)
  12513. ;
  12514. case kExpanded_class: return true
  12515. && equaltTree (yyt1->Expanded_class.Name, yyt2->Expanded_class.Name)
  12516. ;
  12517. case kDeferred_class: return true
  12518. && equaltTree (yyt1->Deferred_class.Name, yyt2->Deferred_class.Name)
  12519. ;
  12520. case kFeatures1: return true
  12521. && equaltTree (yyt1->Features1.Feature_clause, yyt2->Features1.Feature_clause)
  12522. && equaltTree (yyt1->Features1.Features, yyt2->Features1.Features)
  12523. ;
  12524. case kFeature_clause: return true
  12525. && equaltTree (yyt1->Feature_clause.Clients, yyt2->Feature_clause.Clients)
  12526. && (equaltStringRef (yyt1->Feature_clause.comment, yyt2->Feature_clause.comment))
  12527. && equaltTree (yyt1->Feature_clause.Feature_decls, yyt2->Feature_clause.Feature_decls)
  12528. ;
  12529. case kClients1: return true
  12530. && equaltTree (yyt1->Clients1.List, yyt2->Clients1.List)
  12531. ;
  12532. case kFeature_decls1: return true
  12533. && equaltTree (yyt1->Feature_decls1.Feature_decl, yyt2->Feature_decls1.Feature_decl)
  12534. && equaltTree (yyt1->Feature_decls1.Feature_decls, yyt2->Feature_decls1.Feature_decls)
  12535. ;
  12536. case kFeature_decl: return true
  12537. && equaltTree (yyt1->Feature_decl.New_feature_list, yyt2->Feature_decl.New_feature_list)
  12538. && equaltTree (yyt1->Feature_decl.Declaration_body, yyt2->Feature_decl.Declaration_body)
  12539. ;
  12540. case kDeclaration_body: return true
  12541. && equaltTree (yyt1->Declaration_body.Formal_args, yyt2->Declaration_body.Formal_args)
  12542. && equaltTree (yyt1->Declaration_body.Type_mark, yyt2->Declaration_body.Type_mark)
  12543. && equaltTree (yyt1->Declaration_body.Const_or_routine, yyt2->Declaration_body.Const_or_routine)
  12544. ;
  12545. case kM_const: return true
  12546. && equaltTree (yyt1->M_const.Manifest_constant, yyt2->M_const.Manifest_constant)
  12547. ;
  12548. case kUnique: return true
  12549. && (equaltPosition (yyt1->Unique.pos, yyt2->Unique.pos))
  12550. ;
  12551. case kRoutine: return true
  12552. && equaltTree (yyt1->Routine.Obsolete, yyt2->Routine.Obsolete)
  12553. && (equaltStringRef (yyt1->Routine.comment, yyt2->Routine.comment))
  12554. && equaltTree (yyt1->Routine.Precondition, yyt2->Routine.Precondition)
  12555. && equaltTree (yyt1->Routine.Local_decls, yyt2->Routine.Local_decls)
  12556. && equaltTree (yyt1->Routine.Routine_body, yyt2->Routine.Routine_body)
  12557. && equaltTree (yyt1->Routine.Postcondition, yyt2->Routine.Postcondition)
  12558. && equaltTree (yyt1->Routine.Rescue, yyt2->Routine.Rescue)
  12559. && (equaltStringRef (yyt1->Routine.end_comment, yyt2->Routine.end_comment))
  12560. ;
  12561. case kParent_list1: return true
  12562. && equaltTree (yyt1->Parent_list1.Parent, yyt2->Parent_list1.Parent)
  12563. && equaltTree (yyt1->Parent_list1.Parent_list, yyt2->Parent_list1.Parent_list)
  12564. ;
  12565. case kParent: return true
  12566. && equaltTree (yyt1->Parent.Class_type, yyt2->Parent.Class_type)
  12567. && equaltTree (yyt1->Parent.Feature_adaptation, yyt2->Parent.Feature_adaptation)
  12568. ;
  12569. case kFeature_adaptation1: return true
  12570. && equaltTree (yyt1->Feature_adaptation1.Rename, yyt2->Feature_adaptation1.Rename)
  12571. && equaltTree (yyt1->Feature_adaptation1.New_export, yyt2->Feature_adaptation1.New_export)
  12572. && equaltTree (yyt1->Feature_adaptation1.Undefine, yyt2->Feature_adaptation1.Undefine)
  12573. && equaltTree (yyt1->Feature_adaptation1.Redefine, yyt2->Feature_adaptation1.Redefine)
  12574. && equaltTree (yyt1->Feature_adaptation1.Select, yyt2->Feature_adaptation1.Select)
  12575. ;
  12576. case kRename_list1: return true
  12577. && equaltTree (yyt1->Rename_list1.Rename_pair, yyt2->Rename_list1.Rename_pair)
  12578. && equaltTree (yyt1->Rename_list1.Rename_list, yyt2->Rename_list1.Rename_list)
  12579. ;
  12580. case kRename_pair: return true
  12581. && equaltTree (yyt1->Rename_pair.Name1, yyt2->Rename_pair.Name1)
  12582. && equaltTree (yyt1->Rename_pair.Name2, yyt2->Rename_pair.Name2)
  12583. ;
  12584. case kCreators1: return true
  12585. && equaltTree (yyt1->Creators1.Creation_clause, yyt2->Creators1.Creation_clause)
  12586. && equaltTree (yyt1->Creators1.Creators, yyt2->Creators1.Creators)
  12587. ;
  12588. case kCreation_clause: return true
  12589. && equaltTree (yyt1->Creation_clause.Clients, yyt2->Creation_clause.Clients)
  12590. && (equaltStringRef (yyt1->Creation_clause.comment, yyt2->Creation_clause.comment))
  12591. && equaltTree (yyt1->Creation_clause.Feature_list, yyt2->Creation_clause.Feature_list)
  12592. ;
  12593. case kNew_feature_list1: return true
  12594. && equaltTree (yyt1->New_feature_list1.Feature_name, yyt2->New_feature_list1.Feature_name)
  12595. && equaltTree (yyt1->New_feature_list1.New_feature_list, yyt2->New_feature_list1.New_feature_list)
  12596. ;
  12597. case kFrozen: return true
  12598. && equaltTree (yyt1->Frozen.Feature_name, yyt2->Frozen.Feature_name)
  12599. ;
  12600. case kIdent_name: return true
  12601. && equaltTree (yyt1->Ident_name.Id, yyt2->Ident_name.Id)
  12602. ;
  12603. case kPrefix: return true
  12604. && equaltTree (yyt1->Prefix.Op_name, yyt2->Prefix.Op_name)
  12605. ;
  12606. case kInfix: return true
  12607. && equaltTree (yyt1->Infix.Op_name, yyt2->Infix.Op_name)
  12608. ;
  12609. case kOp_name: return true
  12610. && (equaltPosition (yyt1->Op_name.pos, yyt2->Op_name.pos))
  12611. ;
  12612. case kFree_op: return true
  12613. && (equaltPosition (yyt1->Free_op.pos, yyt2->Free_op.pos))
  12614. && (equaltIdent (yyt1->Free_op.ident, yyt2->Free_op.ident))
  12615. ;
  12616. case kOper: return true
  12617. && (equaltPosition (yyt1->Oper.pos, yyt2->Oper.pos))
  12618. && (equalint (yyt1->Oper.op, yyt2->Oper.op))
  12619. ;
  12620. case kNew_export_list1: return true
  12621. && equaltTree (yyt1->New_export_list1.New_export_item, yyt2->New_export_list1.New_export_item)
  12622. && equaltTree (yyt1->New_export_list1.New_export_list, yyt2->New_export_list1.New_export_list)
  12623. ;
  12624. case kNew_export_item: return true
  12625. && equaltTree (yyt1->New_export_item.Clients, yyt2->New_export_item.Clients)
  12626. && equaltTree (yyt1->New_export_item.Feature_set, yyt2->New_export_item.Feature_set)
  12627. ;
  12628. case kFeature_list1: return true
  12629. && equaltTree (yyt1->Feature_list1.Feature_name, yyt2->Feature_list1.Feature_name)
  12630. && equaltTree (yyt1->Feature_list1.Feature_list, yyt2->Feature_list1.Feature_list)
  12631. ;
  12632. case kFormal_args1: return true
  12633. && equaltTree (yyt1->Formal_args1.Entity_decl_group, yyt2->Formal_args1.Entity_decl_group)
  12634. && equaltTree (yyt1->Formal_args1.Formal_args, yyt2->Formal_args1.Formal_args)
  12635. ;
  12636. case kDo_body: return true
  12637. && equaltTree (yyt1->Do_body.Compound, yyt2->Do_body.Compound)
  12638. ;
  12639. case kOnce_body: return true
  12640. && equaltTree (yyt1->Once_body.Compound, yyt2->Once_body.Compound)
  12641. ;
  12642. case kExternal: return true
  12643. && equaltTree (yyt1->External.Lang1, yyt2->External.Lang1)
  12644. && equaltTree (yyt1->External.Lang2, yyt2->External.Lang2)
  12645. ;
  12646. case kDeferred: return true
  12647. && (equaltPosition (yyt1->Deferred.pos, yyt2->Deferred.pos))
  12648. ;
  12649. case kEntity_decl_group: return true
  12650. && equaltTree (yyt1->Entity_decl_group.Id_list, yyt2->Entity_decl_group.Id_list)
  12651. && equaltTree (yyt1->Entity_decl_group.Type_mark, yyt2->Entity_decl_group.Type_mark)
  12652. ;
  12653. case kFormal_generics1: return true
  12654. && equaltTree (yyt1->Formal_generics1.Formal_generic, yyt2->Formal_generics1.Formal_generic)
  12655. && equaltTree (yyt1->Formal_generics1.Formal_generics, yyt2->Formal_generics1.Formal_generics)
  12656. ;
  12657. case kFormal_generic: return true
  12658. && equaltTree (yyt1->Formal_generic.Id, yyt2->Formal_generic.Id)
  12659. && equaltTree (yyt1->Formal_generic.Constraint, yyt2->Formal_generic.Constraint)
  12660. ;
  12661. case kConstraint1: return true
  12662. && equaltTree (yyt1->Constraint1.Class_type, yyt2->Constraint1.Class_type)
  12663. ;
  12664. case kCompound1: return true
  12665. && equaltTree (yyt1->Compound1.Instruction, yyt2->Compound1.Instruction)
  12666. && equaltTree (yyt1->Compound1.Compound, yyt2->Compound1.Compound)
  12667. ;
  12668. case kThen_part_list1: return true
  12669. && equaltTree (yyt1->Then_part_list1.Then_part, yyt2->Then_part_list1.Then_part)
  12670. && equaltTree (yyt1->Then_part_list1.Then_part_list, yyt2->Then_part_list1.Then_part_list)
  12671. ;
  12672. case kThen_part: return true
  12673. && equaltTree (yyt1->Then_part.Guard, yyt2->Then_part.Guard)
  12674. && equaltTree (yyt1->Then_part.Compound, yyt2->Then_part.Compound)
  12675. ;
  12676. case kWhen_part_list1: return true
  12677. && equaltTree (yyt1->When_part_list1.When_part, yyt2->When_part_list1.When_part)
  12678. && equaltTree (yyt1->When_part_list1.When_part_list, yyt2->When_part_list1.When_part_list)
  12679. ;
  12680. case kWhen_part: return true
  12681. && equaltTree (yyt1->When_part.Choices, yyt2->When_part.Choices)
  12682. && equaltTree (yyt1->When_part.Compound, yyt2->When_part.Compound)
  12683. ;
  12684. case kChoices1: return true
  12685. && equaltTree (yyt1->Choices1.Choice, yyt2->Choices1.Choice)
  12686. && equaltTree (yyt1->Choices1.Choices, yyt2->Choices1.Choices)
  12687. ;
  12688. case kInterval: return true
  12689. && equaltTree (yyt1->Interval.From, yyt2->Interval.From)
  12690. && equaltTree (yyt1->Interval.To, yyt2->Interval.To)
  12691. ;
  12692. case kVal: return true
  12693. && equaltTree (yyt1->Val.Manifest_constant, yyt2->Val.Manifest_constant)
  12694. ;
  12695. case kCreation: return true
  12696. && equaltTree (yyt1->Creation.Type, yyt2->Creation.Type)
  12697. && equaltTree (yyt1->Creation.Entity, yyt2->Creation.Entity)
  12698. && equaltTree (yyt1->Creation.Unqual_call, yyt2->Creation.Unqual_call)
  12699. ;
  12700. case kCall_instruct: return true
  12701. && equaltTree (yyt1->Call_instruct.Call, yyt2->Call_instruct.Call)
  12702. ;
  12703. case kAssign: return true
  12704. && equaltTree (yyt1->Assign.Addr, yyt2->Assign.Addr)
  12705. && equaltTree (yyt1->Assign.Expression, yyt2->Assign.Expression)
  12706. ;
  12707. case kRev_assign: return true
  12708. && equaltTree (yyt1->Rev_assign.Addr, yyt2->Rev_assign.Addr)
  12709. && equaltTree (yyt1->Rev_assign.Expression, yyt2->Rev_assign.Expression)
  12710. ;
  12711. case kConditional: return true
  12712. && equaltTree (yyt1->Conditional.Then_part, yyt2->Conditional.Then_part)
  12713. && equaltTree (yyt1->Conditional.Else_part, yyt2->Conditional.Else_part)
  12714. ;
  12715. case kMulti_branch: return true
  12716. && equaltTree (yyt1->Multi_branch.Guard, yyt2->Multi_branch.Guard)
  12717. && equaltTree (yyt1->Multi_branch.When_part_list, yyt2->Multi_branch.When_part_list)
  12718. && equaltTree (yyt1->Multi_branch.Else_part, yyt2->Multi_branch.Else_part)
  12719. ;
  12720. case kLoop: return true
  12721. && equaltTree (yyt1->Loop.Initialization, yyt2->Loop.Initialization)
  12722. && equaltTree (yyt1->Loop.Invariant, yyt2->Loop.Invariant)
  12723. && equaltTree (yyt1->Loop.Variant, yyt2->Loop.Variant)
  12724. && equaltTree (yyt1->Loop.Loop_body, yyt2->Loop.Loop_body)
  12725. ;
  12726. case kCheck: return true
  12727. && equaltTree (yyt1->Check.Assertion, yyt2->Check.Assertion)
  12728. ;
  12729. case kDebug: return true
  12730. && equaltTree (yyt1->Debug.Debug_keys, yyt2->Debug.Debug_keys)
  12731. && equaltTree (yyt1->Debug.Compound, yyt2->Debug.Compound)
  12732. ;
  12733. case kRetry: return true
  12734. && (equaltPosition (yyt1->Retry.pos, yyt2->Retry.pos))
  12735. ;
  12736. case kLoop_body1: return true
  12737. && equaltTree (yyt1->Loop_body1.Exit, yyt2->Loop_body1.Exit)
  12738. && equaltTree (yyt1->Loop_body1.Compound, yyt2->Loop_body1.Compound)
  12739. ;
  12740. case kClass_type: return true
  12741. && equaltTree (yyt1->Class_type.Id, yyt2->Class_type.Id)
  12742. && equaltTree (yyt1->Class_type.Actual_generics, yyt2->Class_type.Actual_generics)
  12743. ;
  12744. case kClass_type_expanded: return true
  12745. && equaltTree (yyt1->Class_type_expanded.Id, yyt2->Class_type_expanded.Id)
  12746. && equaltTree (yyt1->Class_type_expanded.Actual_generics, yyt2->Class_type_expanded.Actual_generics)
  12747. ;
  12748. case kBit_type: return true
  12749. && equaltTree (yyt1->Bit_type.Manifest_constant, yyt2->Bit_type.Manifest_constant)
  12750. ;
  12751. case kSimple_type: return true
  12752. && equaltTree (yyt1->Simple_type.Manifest_constant, yyt2->Simple_type.Manifest_constant)
  12753. ;
  12754. case kAnchored: return true
  12755. && equaltTree (yyt1->Anchored.Entity, yyt2->Anchored.Entity)
  12756. ;
  12757. case kActual_generics1: return true
  12758. && equaltTree (yyt1->Actual_generics1.Type_list, yyt2->Actual_generics1.Type_list)
  12759. ;
  12760. case kCondition1: return true
  12761. && (equalint (yyt1->Condition1.extension, yyt2->Condition1.extension))
  12762. && equaltTree (yyt1->Condition1.Assertion, yyt2->Condition1.Assertion)
  12763. ;
  12764. case kAssertion1: return true
  12765. && equaltTree (yyt1->Assertion1.Assertion_clause, yyt2->Assertion1.Assertion_clause)
  12766. && equaltTree (yyt1->Assertion1.Assertion, yyt2->Assertion1.Assertion)
  12767. ;
  12768. case kAssertion_clause1: return true
  12769. && equaltTree (yyt1->Assertion_clause1.Tag, yyt2->Assertion_clause1.Tag)
  12770. && equaltTree (yyt1->Assertion_clause1.Expression, yyt2->Assertion_clause1.Expression)
  12771. ;
  12772. case kType_list1: return true
  12773. && equaltTree (yyt1->Type_list1.Type, yyt2->Type_list1.Type)
  12774. && equaltTree (yyt1->Type_list1.Type_list, yyt2->Type_list1.Type_list)
  12775. ;
  12776. case kCall_chain1: return true
  12777. && equaltTree (yyt1->Call_chain1.Unqual_call, yyt2->Call_chain1.Unqual_call)
  12778. && equaltTree (yyt1->Call_chain1.Call_chain, yyt2->Call_chain1.Call_chain)
  12779. ;
  12780. case kUnqual_call1: return true
  12781. && equaltTree (yyt1->Unqual_call1.Entity, yyt2->Unqual_call1.Entity)
  12782. && equaltTree (yyt1->Unqual_call1.Actuals, yyt2->Unqual_call1.Actuals)
  12783. ;
  12784. case kActuals1: return true
  12785. && equaltTree (yyt1->Actuals1.Actual_list, yyt2->Actuals1.Actual_list)
  12786. ;
  12787. case kActual_list1: return true
  12788. && equaltTree (yyt1->Actual_list1.Actual, yyt2->Actual_list1.Actual)
  12789. && equaltTree (yyt1->Actual_list1.Actual_list, yyt2->Actual_list1.Actual_list)
  12790. ;
  12791. case kAddr: return true
  12792. && equaltTree (yyt1->Addr.Entity, yyt2->Addr.Entity)
  12793. ;
  12794. case kComment: return true
  12795. && (equaltStringRef (yyt1->Comment.comment, yyt2->Comment.comment))
  12796. ;
  12797. case kSimple_expr: return true
  12798. && equaltTree (yyt1->Simple_expr.Manifest_constant, yyt2->Simple_expr.Manifest_constant)
  12799. ;
  12800. case kCall: return true
  12801. && equaltTree (yyt1->Call.Qual, yyt2->Call.Qual)
  12802. && equaltTree (yyt1->Call.Call_chain, yyt2->Call.Call_chain)
  12803. ;
  12804. case kBin_expr: return true
  12805. && equaltTree (yyt1->Bin_expr.Lop, yyt2->Bin_expr.Lop)
  12806. && equaltTree (yyt1->Bin_expr.Op, yyt2->Bin_expr.Op)
  12807. && equaltTree (yyt1->Bin_expr.Rop, yyt2->Bin_expr.Rop)
  12808. ;
  12809. case kUn_expr: return true
  12810. && equaltTree (yyt1->Un_expr.Op, yyt2->Un_expr.Op)
  12811. && equaltTree (yyt1->Un_expr.Expression, yyt2->Un_expr.Expression)
  12812. ;
  12813. case kParenth: return true
  12814. && equaltTree (yyt1->Parenth.Expression, yyt2->Parenth.Expression)
  12815. ;
  12816. case kManifest_array1: return true
  12817. && equaltTree (yyt1->Manifest_array1.Expression, yyt2->Manifest_array1.Expression)
  12818. && equaltTree (yyt1->Manifest_array1.Manifest_array, yyt2->Manifest_array1.Manifest_array)
  12819. ;
  12820. case kOld: return true
  12821. && equaltTree (yyt1->Old.Expression, yyt2->Old.Expression)
  12822. ;
  12823. case kStrip: return true
  12824. && equaltTree (yyt1->Strip.List, yyt2->Strip.List)
  12825. ;
  12826. case klist: return true
  12827. && equaltTree (yyt1->list.Manifest_constant, yyt2->list.Manifest_constant)
  12828. && equaltTree (yyt1->list.List, yyt2->list.List)
  12829. ;
  12830. case kCh: return true
  12831. && (equalint (yyt1->Ch.ch, yyt2->Ch.ch))
  12832. && (equaltPosition (yyt1->Ch.pos, yyt2->Ch.pos))
  12833. ;
  12834. case kTrue: return true
  12835. && (equaltPosition (yyt1->True.pos, yyt2->True.pos))
  12836. ;
  12837. case kFalse: return true
  12838. && (equaltPosition (yyt1->False.pos, yyt2->False.pos))
  12839. ;
  12840. case kInt: return true
  12841. && equaltTree (yyt1->Int.Sign, yyt2->Int.Sign)
  12842. && (equallong (yyt1->Int.value, yyt2->Int.value))
  12843. && (equaltPosition (yyt1->Int.pos, yyt2->Int.pos))
  12844. ;
  12845. case kReal: return true
  12846. && equaltTree (yyt1->Real.Sign, yyt2->Real.Sign)
  12847. && (equaldouble (yyt1->Real.value, yyt2->Real.value))
  12848. && (equaltPosition (yyt1->Real.pos, yyt2->Real.pos))
  12849. ;
  12850. case k_CHARACTER: return true
  12851. && (equaltPosition (yyt1->_CHARACTER.pos, yyt2->_CHARACTER.pos))
  12852. ;
  12853. case k_INTEGER: return true
  12854. && (equaltPosition (yyt1->_INTEGER.pos, yyt2->_INTEGER.pos))
  12855. ;
  12856. case k_REAL: return true
  12857. && (equaltPosition (yyt1->_REAL.pos, yyt2->_REAL.pos))
  12858. ;
  12859. case k_DOUBLE: return true
  12860. && (equaltPosition (yyt1->_DOUBLE.pos, yyt2->_DOUBLE.pos))
  12861. ;
  12862. case k_BOOLEAN: return true
  12863. && (equaltPosition (yyt1->_BOOLEAN.pos, yyt2->_BOOLEAN.pos))
  12864. ;
  12865. case k_STRING: return true
  12866. && (equaltPosition (yyt1->_STRING.pos, yyt2->_STRING.pos))
  12867. ;
  12868. case k_BIT: return true
  12869. && (equaltPosition (yyt1->_BIT.pos, yyt2->_BIT.pos))
  12870. ;
  12871. case k_NONE: return true
  12872. && (equaltPosition (yyt1->_NONE.pos, yyt2->_NONE.pos))
  12873. ;
  12874. case kBitseq: return true
  12875. && (equaltStringRef (yyt1->Bitseq.literal, yyt2->Bitseq.literal))
  12876. && (equaltPosition (yyt1->Bitseq.pos, yyt2->Bitseq.pos))
  12877. ;
  12878. case kString: return true
  12879. && (equaltStringRef (yyt1->String.string, yyt2->String.string))
  12880. && (equaltPosition (yyt1->String.pos, yyt2->String.pos))
  12881. ;
  12882. case kCurrent: return true
  12883. && (equaltPosition (yyt1->Current.pos, yyt2->Current.pos))
  12884. ;
  12885. case kResult: return true
  12886. && (equaltPosition (yyt1->Result.pos, yyt2->Result.pos))
  12887. ;
  12888. case kId: return true
  12889. && (equaltIdent (yyt1->Id.ident, yyt2->Id.ident))
  12890. && (equaltPosition (yyt1->Id.pos, yyt2->Id.pos))
  12891. ;
  12892.  default: return true;
  12893.  }
  12894. }
  12895.  
  12896. void BeginTree ()
  12897. {
  12898. }
  12899.  
  12900. void CloseTree ()
  12901. {
  12902. }
  12903.